SMMP/build/database/repo/action_merge.php

<?php

	namespace database\repo;
	use \database\core\DatabaseDriver;
	use \database\core\Repo;
	use \error\core\Error;
	use \orm\core\Table;
	use \orm\core\Rows;


	class action_merge extends parentRepo{

		protected static function table_name(){ static $table_name = 'action_merge'; return $table_name;  }


		/* AJOUT D'UNE PERMISSION ENTRE 2 GROUPES (UTIL -> MACHINE)
		*
		* @id_target<int> 									UID d'un groupe MACHINE
		* @id_source<int> 									UID d'un groupe UTILISATEUR
		* @id_action<int> 									UID d'une ACTION
		*
		* @return error<Error> 									Retourne l'erreur 'Error' associée
		*
		*/
		public static function addPermission($id_target, $id_source, $id_action){

			/* [1] On vérifie l'existance du groupe 'target'
			=========================================================*/
			/* (1) On rédige la requête */
			$targetCheckR = new Repo('machine_cluster/getById', [
				$_SESSION['WAREHOUSE']['id'],
				$id_target
			]);
			$targetCheck = $targetCheckR->answer();

			/* (2) Si aucun résultat, on retourne une erreur */
			if( $targetCheck === false )
				return Error::NoMatchFound;


			/* [2] On vérifie l'existance du groupe 'source'
			=========================================================*/
			/* (1) On rédige la requête */
			$sourceCheckR = new Repo('user_cluster/getById', [
				$_SESSION['WAREHOUSE']['id'],
				$id_source
			]);
			$sourceCheck = $sourceCheckR->answer();

			/* (2) Si aucun résultat, on retourne une erreur */
			if( $sourceCheck === false )
				return Error::NoMatchFound;


			/* [3] On vérifie l'existance de l'action
			=========================================================*/
			/* (1) On rédige la requête */
			$actionCheckR = new Repo('action/getById', [ $id_action ]);
			$actionCheck = $actionCheckR->answer();

			/* (2) Si aucun résultat, on retourne une erreur */
			if( $actionCheck === false )
				return Error::NoMatchFound;


			/* [4] On vérifie que l'entrée n'existe pas déja
			=========================================================*/
			/* (1) On effectue la requête */
			$checkAlready = self::getByIdTarget($id_target);

			/* (2) Si on a un résultat, on continue la vérification */
			if( is_array($checkAlready) && count($checkAlready) > 0 ){

				/* (3) Si les données sont identiques pour au moins une entrée, on retourne un succès */
				foreach($checkAlready as $s=>$sameTarget)
					if( $sameTarget['id_source'] == $id_source && $sameTarget['id_action'] == $id_action )
						return Error::Success;

			}


			/* [5] On ajoute la action
			=========================================================*/
			/* (1) On effectue l'insertion */
			$inserted = Table::get('action_merge')
				->insert([
					'id_action_merge' => Rows::INSERT_DEFAULT,
					'id_target'       => $id_target,
					'id_source'       => $id_source,
					'id_action'       => $id_action
				]);

			/* (2) Si erreur SQL, on retourne une erreur */
			if( !$inserted )
				return Error::RepoError;


			return Error::Success;
		}









		/* SUPPRESSION D'UNE PERMISSION ENTRE 2 GROUPES (UTIL -> MACHINE)
		*
		* @id_target<int> 									UID d'un groupe MACHINE
		* @id_source<int> 									UID d'un groupe UTILISATEUR
		* @id_action<int> 									UID d'une PERMISSION
		*
		* @return error<Error> 						Retourne l'erreur 'Error' associée
		*
		*/
		public static function removePermission($id_target, $id_source, $id_action){

			/* [1] On vérifie que l'entrée existe
			=========================================================*/
			/* (1) On effectue la requête */
			$checkExists = self::getByIdTarget($id_target);

			/* (2) Si on a un résultat correspondant aux données, c'est bon */
			$existingId = null;
			if( is_array($checkExists) && count($checkExists) > 0 ){

				/* (3) Si les données sont identiques pour au moins une entrée, on peut supprimer */
				foreach($checkExists as $s=>$sameTarget)
					if( $sameTarget['id_source'] == $id_source && $sameTarget['id_action'] == $id_action )
						$existingId = $sameTarget['id_action_merge'];
			}

			/* (3) Si on a pas trouvé, on retourne une erreur */
			if( is_null($existingId) )
				return Error::NoMatchFound;


			/* [2] On supprime la action
			=========================================================*/
			/* (1) On effectue la suppression */
			$deleted = Table::get('action_merge')
				->whereId($existingId)
				->whereIdTarget($id_target)
				->whereIdSource($id_source)
				->whereIdAction($id_action)
				->unique()
				->delete();

			/* (2) Si erreur SQL, on retourne une erreur */
			if( !$deleted || self::getById($existingId) !== false )
				return Error::RepoError;


			return Error::Success;
		}










		/* RETOURNE LA LISTE DES UTILISATEURS AYANT LES PERMISSIONS POUR UNE MACHINE D'ID DONNE
		*
		* @id_warehouse<int> 									UID de l'entrepot
		* @id_machine<int> 									UID de la machine
		*
		* @return permissions<Array> 								Liste des accès des utilisateurs à cette machine
		*
		*/
		public static function getAccess($id_warehouse, $id_machine){

			//TODO: GROUP_CONCAT(DISTINCT a.id_action ORDER BY a.id_action ASC)
			$u = Table::get('user')
				->select('id_user')
				->select('code');

			$ucm = Table::get('user_cluster_merge')
				->join('id_user', $u);

			$m = Table::get('machine')
				->whereId(5);

			$mcm = Table::get('machine_cluster_merge')
				->join('id_machine', $m);

			$am= Table::get('action_merge')
				->join('id_source', $ucm)
				->join('id_target', $mcm)
				->select('id_action', Rows::SEL_CONCAT, Rows::SEL_DISTINCT);

			return $am->fetch();
		}

		



		/* RETOURNE LA LISTE DES PERMISSIONS EXISTANTES
		*
		* @return permissions<Array> 							Liste des permissions
		*
		*/
		public static function getPermissions(){

			/* (1) Liste des permissions existantes */
			$availablePermissions = Table::get('action')
				->select('id_action', null, null, 'id_permission')
				->select('name');

			return $availablePermissions->fetch();
		}


		/* RETOURNE LES GROUPES D'UTILISATEURS AYANT UNE PERMISSION SUR UN GROUPE DE MACHINE
		*
		* @id_warehouse<int> 									UID de l'entrepot
		* @id_target<int> 								UID du groupe de machine
		* @id_action<int> 								UID de l'action
		*
		* @return clusters<Array> 							Liste des user_cluster ayant la permission sur le groupe target
		*
		*/
		public static function getAuthenticatedClusters($id_warehouse, $id_target, $id_action){
		
			/* [1] On rédige la requête
			=========================================================*/
			/* (1) On récupère les groupes (on construit le selecteur) */
			$clusters = Table::get('user_cluster')
				->whereIdWarehouse($id_warehouse)
				->select('id_user_cluster')
				->select('name');

			/* (2) On rédige le "fetcher" */
			$fetcher = Table::get('action_merge')
				->whereIdTarget($id_target)
				->whereIdAction($id_action)
				->join('id_source', $clusters);
			
			return $fetcher->fetch();
		}
	}


?>