fdn2/private/lib/dao/mediaModels/DaoMediaHandler.php

<?php

class DaoMediaHandler implements MediaHandlerInterface{
	
	/**
	 * 
	 * @param HasMediaInterface $news
	 * @return MediaInterface[] $media
	 * Ritorna un array con i media model della news
	 */
	public static function getMedias(HasMediaInterface $model){
		$newsReference = $model->getMediaReferences();
		$referenceIds = array();
		if (sizeof($newsReference)>0){
			foreach ($newsReference as $ref){
				$referenceIds[] = new MongoId($ref);
			}
		}
		$rval = array();
// 		var_dump($newsReference);
		$rval = GlobalVariables::get("dao")->query("MediaModel",array('id'=>array('$in'=>$referenceIds)));
// 	var_dump($rval);
		return $rval;
	}
	
	
	/**
	 * Aggiunge il media al model e controlla se il model ha un main media e se non lo ha glielo assegna  (salva sia il media che la news).
	 * @param HasMediaInterface $model
	 * @param MediaInterface $media
	 * @throws MediaException
	 */
	public static function addMedia(HasMediaInterface $model, MediaInterface $media){
		if(!$model->hasProperty("id")){
			throw new MediaException("Invalid HasMediaInterface passed to DaoMediaHandler::addMedia (no property ID)");
		}
		if(!$media->hasProperty("id")){
			throw new MediaException("Invalid MediaInterface passed to DaoMediaHandler::addMedia (no property ID)");
		}
		
		try{
			$mediaArr = array();
			$mediaArr = $model->getMediaReferences();
			if(!in_array($media->getReference(), $mediaArr)){
				$mediaArr[] = $media->getReference();
				$model->setMediaReferences($mediaArr);
				
				if(!DaoMediaHandler::hasMainMedia($model)){
					$model->setMainMedia($media);
				}
				GlobalVariables::get("dao")->save($model);
				
				self::setOwnerToMedia($model, $media);
// 				$media->setOwnerReference($model);
				GlobalVariables::get("dao")->save($media);
			}
		}catch(CoreException $ex){
			throw new MediaException("Error while saving in DaoMediaHandler::addMedia (".$ex->getMessage().")");
		}
	}
	
	/**
	 * Elimina l'id del media dal model e deleta il media. Se il media è il main media della news lo unsetta
	 * 
	 * @param HasMediaInterface $model
	 * @param MediaInterface $media
	 * @throws MediaException
	 */
	public static function deleteMedia(HasMediaInterface $model, MediaInterface $media){
		try{
			
			$mediaArr = array();
			$mediaArr = $model->getMediaReferences();
			$mediaId = $media->getReference();
			
// 			var_dump($mediaArr);
			if(sizeof($mediaArr)>0){
				$key = array_search($mediaId, $mediaArr);
				if($key !== false){
					unset($mediaArr[$key]);
					$model->setMediaReferences($mediaArr);
					
					if($model->getMainMediaReference() == $mediaId){
						$medias = self::getMedias($model);
						if (sizeof($medias)>0){
							if ($media->getReference() == $medias[0]->getReference()){
								$model->setMainMedia($medias[1]);
							}
							else {
								$model->setMainMedia($medias[0]);
							}
						}
						else {
							$model->setMainMedia(null);
						}
// 						echo "UGUALE!";
						
					}
					
					GlobalVariables::get("dao")->save($model);
					
					GlobalVariables::get("dao")->delete($media);
				}
				else{
					throw new MediaException("Trying to delete invalid media from a model in DaoMediaHandler::deleteMedia");
				}
			}
			else{
				throw new MediaException("This HasMediaInterface has no media in it '".$model->id."' sizeof on mediaReference failed in DaoMediaHandler::deleteMedia");
			}
	
		}catch(CoreException $ex){
			throw new MediaException("Error while deleting in DaoMediaHandler::deleteMedia (".$ex->getMessage().")");
		}
	}
	
	/**
	 * Elimina tutti i media associati al contenuto
	 * @param HasMediaInterface $model
	 */
	public static function deleteAllMedias(HasMediaInterface $model){
		$medias = self::getMedias($model);
		if (sizeof($medias)>0){
			foreach ($medias as $media){
				self::deleteMedia($model, $media);
			}
		}
	}
	
	/**
	 * Setta l'owner al MediaModel
	 * @param HasMediaInterface $model
	 * @param MediaModel $media
	 */
	public static function setOwnerToMedia(HasMediaInterface $model, MediaModel $media){
		$media->setOwnerReference($model);
	}
	
	/**
	 *
	 * @param MediaInterface $media
	 * @throws MediaException
	 * @return DaoSaveable
	 */
	public static function getMediaOwnerFromMedia(MediaInterface $media){
		$ownerRef = $media->getOwnerReference();
		try{
			$owner = GlobalVariables::get("dao")->getFirst($ownerRef->class,array("id"=>$ownerRef->id));
			return $owner;
		}catch(CoreException $ex){
			throw new MediaException("Invalid Media Reference trying get Media Owner in DaoMediaHandler::getMEdiaOwner");
		}
	}
	
	/**
	 * 
	 * @param HasMediaInterface $model
	 * @param MediaInterface $media
	 * @throws MediaException
	 */
	public static function setMainMediaToModel(HasMediaInterface $model, MediaInterface $media){
		try{
			self::addMedia($model, $media);
			$model->setMainMedia($media);
			GlobalVariables::get("dao")->save($model);
		}catch(CoreException $ex){
			throw new MediaException("Error while trying to save an HasMediaInterface in ModelHandler::setMainMedia");
		}
	}
	
	/**
	 * Prende in ingresso un HasMediaInterface ritorna un MediaModel o null;
	 * 
	 * @param HasMediaInterface $model
	 * @return MediaModel
	 */
	public static function getMainMediaFromModel(HasMediaInterface $model){
		$mainMedia = $model->getMainMediaReference();
		$tmp = null;
		if(!is_null($mainMedia)){
			$mainMediaId = new MongoId($mainMedia);
			$tmp = GlobalVariables::get("dao")->getFirst("MediaModel",array("id"=>$mainMediaId));
		}
// 		var_dump($tmp);
		return $tmp;
	}
	
	/**
	 * Richiede un saveable object con almeno la proprietà mediaType e il path del file
	 * 
	 * @param stdClass $saveableObj
	 * @param string $filePath
	 * @return MediaModel
	 */
	public static function createNewFileBasedMedia($saveableObj, $filePath,$extension){
		$basepath = GlobalVariables::get("config")->paths->media;
		$media = new MediaModel($saveableObj);
		$media->extension = $extension;
		GlobalVariables::get("dao")->save($media);
		SFSManager::copyFile($filePath, $basepath."/".$media->id.".".$media->extension);
		return $media;
	}
	
	/**
	 * Richiede un saveable object con la proprietà mediaType settata
	 * 
	 * @param stdClass $saveable
	 * @return MediaModel
	 */
	public static function createNewTextBasedMedia($saveable){
		$media = new MediaModel($saveable);
		GlobalVariables::get("dao")->save($media);
		return $media;
	}
	
	public static function hasMainMedia(HasMediaInterface $model){
		$hasMainMedia = false;
		if(!is_null($model->getMainMediaReference())){
			$hasMainMedia = true;
		}
		return $hasMainMedia;
	}
	
}

?>