464 lines
11 KiB
PHP
Executable File
464 lines
11 KiB
PHP
Executable File
<?php
|
|
|
|
namespace api\module;
|
|
use \viewer\core\Viewer;
|
|
use \database\core\DatabaseDriver;
|
|
use \manager\sessionManager;
|
|
use \error\core\Error;
|
|
use \database\core\Repo;
|
|
use \manager\repo\cluster as clusterRepo;
|
|
|
|
class clusterDefault{
|
|
|
|
public function __construct(){}
|
|
public function __destruct(){}
|
|
|
|
/* CREATION D'UN NOUVEL UTILISATEUR DANS LA BDD
|
|
*
|
|
* @name<String> Nom du groupe
|
|
* @class<int> Type de groupe (0:user;1:machine)
|
|
*
|
|
* @return id_cluster<int> Retourne l'UID du groupe
|
|
*
|
|
*/
|
|
public function create($params){
|
|
extract($params);
|
|
|
|
/* [2] Creation du groupe
|
|
=========================================================*/
|
|
$repoMethod = ($class==0) ? 'user_cluster/create' : 'machine_cluster/create';
|
|
|
|
$create_cluster = new Repo($repoMethod, [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$name
|
|
]);
|
|
$id_cluster = $create_cluster->answer();
|
|
|
|
|
|
// Si une erreur est retournee, on retourne une erreur
|
|
if( $id_cluster === false )
|
|
return ['error' => new Error(Err::error)];
|
|
|
|
|
|
/* [5] Gestion du retour
|
|
=========================================================*/
|
|
return [
|
|
'id_cluster' => $id_cluster
|
|
];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE UN GROUPE EN FONCTION D'UN MOT CLE
|
|
*
|
|
* @keywords<String> Element de recherche
|
|
* @class<int> Type de groupe (0:user;1:machine) [OPTIONNEL]
|
|
*
|
|
* @return clusters<Array> Retourne la liste des groupes trouves
|
|
*
|
|
*/
|
|
public function search($params){
|
|
extract($params);
|
|
|
|
$result = [];
|
|
|
|
if( is_null($class) || $class == 0 ){
|
|
|
|
// On recupere les donnees des groupes utilisateurs
|
|
$userClusters = new Repo('user_cluster/search', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$keywords
|
|
]);
|
|
|
|
$result = array_merge($result, $userClusters->answer());
|
|
|
|
}
|
|
|
|
if( is_null($class) || $class == 1 ){
|
|
|
|
// On recupere les donnees des groupes utilisateurs
|
|
$machineClusters = new Repo('machine_cluster/search', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$keywords
|
|
]);
|
|
|
|
$result = array_merge($result, $machineClusters->answer());
|
|
|
|
}
|
|
|
|
|
|
return [ 'clusters' => $result ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE EXHAUSTIVE DES GROUPES
|
|
*
|
|
* @class<int> Type de groupe
|
|
*
|
|
* @return clusters<Array> Liste des groupes
|
|
*
|
|
*/
|
|
public function getAll($params){
|
|
extract($params);
|
|
|
|
$result = [];
|
|
|
|
if( is_null($class) || $class == 0 ){
|
|
|
|
// On recupere les donnees des groupes utilisateurs
|
|
$userClusters = new Repo('user_cluster/getAll', [
|
|
$_SESSION['WAREHOUSE']['id']
|
|
]);
|
|
|
|
$result = array_merge($result, $userClusters->answer());
|
|
|
|
}
|
|
|
|
if( is_null($class) || $class == 1 ){
|
|
|
|
// On recupere les donnees des groupes utilisateurs
|
|
$machineClusters = new Repo('machine_cluster/getAll', [
|
|
$_SESSION['WAREHOUSE']['id']
|
|
]);
|
|
|
|
$result = array_merge($result, $machineClusters->answer());
|
|
|
|
}
|
|
|
|
|
|
return [ 'clusters' => $result ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE UN GROUPE D'UID DONNE
|
|
*
|
|
* @id_cluster<int> UID du groupe en question
|
|
* @class<int> Type de groupe
|
|
*
|
|
* @return cluster<Array> Groupe d'UID donne
|
|
*
|
|
*/
|
|
public function getById($params){
|
|
extract($params);
|
|
|
|
$repoMethod = ($class==0) ? 'user_cluster/getById' : 'machine_cluster/getById';
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo($repoMethod, [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
// Si aucun resultat, on retourne une erreur
|
|
if( $answer === false )
|
|
return [ 'error' => new Error(Err::NoMatchFound) ];
|
|
|
|
|
|
return [ 'cluster' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE UN GROUPE DE NOM DONNE
|
|
*
|
|
* @name<String> Nom du groupe en question
|
|
* @class<int> Type de groupe
|
|
*
|
|
* @return cluster<Array> Groupe de nom donne
|
|
*
|
|
*/
|
|
public function getByName($params){
|
|
extract($params);
|
|
|
|
$repoMethod = ($class==0) ? 'user_cluster/getByName' : 'machine_cluster/getByName';
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo($repoMethod, [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$name
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
// Si aucun resultat, on retourne une erreur
|
|
if( $answer === false )
|
|
return [ 'error' => new Error(Err::NoMatchFound) ];
|
|
|
|
|
|
return [ 'cluster' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES MEMBRES D'UN GROUPE DONNE
|
|
*
|
|
* @id_cluster<int> UID du groupe en question
|
|
* @class<int> Type du groupe en question
|
|
*
|
|
* @return members<Array> Membres du groupe donne
|
|
*
|
|
*/
|
|
public function getMembers($params){
|
|
extract($params);
|
|
|
|
$repoMethod = ($class==0) ? 'user_cluster/getMembers' : 'machine_cluster/getMembers';
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo($repoMethod, [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
// Si aucun resultat, on retourne une erreur
|
|
if( $answer === false )
|
|
return [ 'error' => new Error(Err::NoMatchFound) ];
|
|
|
|
|
|
return [ 'members' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* MODIFIE UN groupe DONNEE
|
|
*
|
|
* @id_cluster<int> UID du groupe
|
|
* @class<int> Type de groupe
|
|
* @name<String> Nouveau nom
|
|
*
|
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien deroule
|
|
*
|
|
*/
|
|
public function edit($params){
|
|
extract($params);
|
|
|
|
|
|
/* [1] On verifie l'existence du groupe
|
|
=========================================================*/
|
|
$repo = ($class==0) ? 'user_cluster' : 'machine_cluster';
|
|
|
|
$cluster_exists = new Repo($repo.'/getById', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster
|
|
]);
|
|
$cluster_data = $cluster_exists->answer();
|
|
|
|
// Si on a recupere aucun utilisateur, on retourne une erreur
|
|
if( $cluster_data === false )
|
|
return ['error' => new Error(Err::NoMatchFound)];
|
|
|
|
|
|
|
|
/* [2] Normalisation + verification des donnees
|
|
=========================================================*/
|
|
/* (1) Verification des parametres (si non nul + differents)*/
|
|
$diff_param = [
|
|
'name' => $cluster_data['name'] != $name
|
|
];
|
|
|
|
/* (2) Gestion des parametres optionnels */
|
|
$opt_data = [
|
|
'name' => ($diff_param['name']) ? $name : $cluster_data['name'],
|
|
];
|
|
|
|
|
|
/* [3] Modification du groupe
|
|
=========================================================*/
|
|
$request = new Repo($repo.'/edit', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster,
|
|
$opt_data['name'],
|
|
]);
|
|
|
|
|
|
return [ 'status' => $request->answer() ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* SUPPRIME UN UTILISATEUR DONNEE
|
|
*
|
|
* @id_cluster<int> UID du groupe en question
|
|
* @class<int> Type de groupe
|
|
*
|
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien deroule
|
|
*
|
|
*/
|
|
public function delete($params){
|
|
extract($params);
|
|
|
|
$repoMethod = ($class==0) ? 'user_cluster/delete' : 'machine_cluster/delete';
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo($repoMethod, [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
return [ 'status' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
/* AJOUTE UNE PERMISSION
|
|
*
|
|
* @id_target<int> UID du groupe de machine cible
|
|
* @id_source<int> UID du groupe d'utilisateur source
|
|
* @id_action<int> UID de l'action en question
|
|
*
|
|
*/
|
|
public function addPermission($params){
|
|
extract($params);
|
|
|
|
/* [1] On crée la relation via le repo
|
|
=========================================================*/
|
|
/* (1) On rédige la requête */
|
|
$req = new Repo('action_merge/addPermission', [$id_target, $id_source, $id_action]);
|
|
|
|
/* (2) On éxecute + récupère la réponse (code erreur) */
|
|
$res = $req->answer();
|
|
|
|
|
|
/* [2] On propage l'erreur retournée
|
|
=========================================================*/
|
|
return [ 'error' => $res ];
|
|
}
|
|
|
|
/* SUPPRIME UNE PERMISSION
|
|
*
|
|
* @id_target<int> UID du groupe de machine cible
|
|
* @id_source<int> UID du groupe d'utilisateur source
|
|
* @id_action<int> UID de l'action en question
|
|
*
|
|
*/
|
|
public function remPermission($params){
|
|
extract($params);
|
|
|
|
/* [1] On supprime la relation via le repo
|
|
=========================================================*/
|
|
/* (1) On rédige la requête */
|
|
$req = new Repo('action_merge/removePermission', [$id_target, $id_source, $id_action]);
|
|
|
|
/* (2) On exécute + récupère la réponse (code erreur) */
|
|
$res = $req->answer();
|
|
|
|
|
|
/* [2] On propage l'erreur retournée
|
|
=========================================================*/
|
|
return [ 'error' => $res ];
|
|
}
|
|
|
|
|
|
/* RETOURNE LA LISTE DES PERMISSIONS EXISTANTES
|
|
*
|
|
* @id_cluster<int> UID du groupe machine en question
|
|
*
|
|
* @return permissions<Array> Liste des permissions du groupe
|
|
*
|
|
*/
|
|
public function getPermissions($params){
|
|
extract($params);
|
|
|
|
/* [1] On propage au repo
|
|
=========================================================*/
|
|
/* (1) On rédige la requête */
|
|
$req = new Repo('action_merge/getPermissions', []);
|
|
|
|
/* (2) On exécute et récupère la réponse */
|
|
$res = $req->answer();
|
|
|
|
// Gestion erreur
|
|
if( !is_array($res) )
|
|
return ['error' => new Error(Err::NoMatchFound)];
|
|
|
|
/* (3) On retourne le résultat */
|
|
return [ 'permissions' => $res ];
|
|
}
|
|
|
|
|
|
/* RETOURNE LES GROUPES D'UTILISATEURS AYANT UNE PERMISSION SUR UN GROUPE DE MACHINE
|
|
*
|
|
* @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 function getAuthenticatedClusters($params){
|
|
extract($params);
|
|
|
|
/* [1] On propage au repo
|
|
=========================================================*/
|
|
$req = new Repo('action_merge/getAuthenticatedClusters', [$_SESSION['WAREHOUSE']['id'], $id_target, $id_action]);
|
|
|
|
$res = $req->answer();
|
|
|
|
// error
|
|
if( !is_array($res) )
|
|
return ['error' => new Error(Err::NoMatchFound)];
|
|
|
|
return ['clusters' => $res];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RETOURNE LA LISTE DES MODULE D'UN GROUPE DE MACHINES
|
|
*
|
|
* @id_cluster<int> UID du groupe de machine
|
|
*
|
|
* @return modules<Array> Liste des modules autorisés pour le groupe de machines
|
|
*
|
|
*/
|
|
public static function getModules($params){
|
|
extract($params);
|
|
|
|
|
|
/* [1] On récupère les modules
|
|
=========================================================*/
|
|
/* (1) Récupération */
|
|
$mod_req = new Repo('module/getByMachineCluster', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster
|
|
]);
|
|
|
|
$answer = $mod_req->answer();
|
|
|
|
/* (2) Gestion erreur */
|
|
if( $answer === false )
|
|
return ['error' => new Error(Err::NoMatchFound)]; // no error
|
|
|
|
|
|
/* [3] On retourne la liste
|
|
=========================================================*/
|
|
return [ 'modules' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
?>
|