651 lines
15 KiB
PHP
Executable File
651 lines
15 KiB
PHP
Executable File
<?php
|
|
|
|
namespace api\module;
|
|
use \database\core\DatabaseDriver;
|
|
use \manager\sessionManager;
|
|
use \error\core\Error;
|
|
use \error\core\Err;
|
|
use \database\core\Repo;
|
|
use \api\core\Request;
|
|
|
|
class machineDefault{
|
|
|
|
public function __construct(){}
|
|
public function __destruct(){}
|
|
|
|
|
|
/* CREATION D'UNE NOUVELLE MACHINE DANS LA BDD
|
|
*
|
|
* @name<String> Identifiant de la machine
|
|
*
|
|
* @return status<Boolean> Retourne si oui ou non, tout s'est bien passe
|
|
*
|
|
*/
|
|
public function create($params){
|
|
extract($params);
|
|
|
|
/* [1] Creation de la machine
|
|
=========================================================*/
|
|
$create_machine = new Repo('machine/create', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$name
|
|
]);
|
|
$id_machine = $create_machine->answer();
|
|
|
|
// Si une erreur est retournee, on retourne une erreur
|
|
if( $id_machine === false )
|
|
return ['error' => new Error(Err::ModuleError)];
|
|
|
|
|
|
|
|
/* [2] Gestion du retour
|
|
=========================================================*/
|
|
return [
|
|
'id_machine' => $id_machine
|
|
];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* AJOUTE UNE MACHINE DONNEE A UN GROUPE DONNE
|
|
*
|
|
* @id_cluster<int> UID du groupe
|
|
* @id_machine<int> UID de la machine
|
|
*
|
|
* @return association<int> Renvoie l'UID de l'association cree
|
|
* Renvoie FALSE si une erreur occure
|
|
*
|
|
*/
|
|
public function link($params){
|
|
extract($params);
|
|
|
|
/* Creation de l'association */
|
|
$link_machine = new Repo('machine_cluster/link', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster,
|
|
$id_machine
|
|
]);
|
|
|
|
/* (1) On retourne l'erreur du repo */
|
|
return [ 'error' => $link_machine->answer() ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RETIRE UNE MACHINE DONNEE A UN GROUPE DONNE
|
|
*
|
|
* @id_cluster<int> UID du groupe
|
|
* @id_machine<int> UID de la machine
|
|
*
|
|
* @return association<int> Renvoie l'UID de l'association cree
|
|
* Renvoie FALSE si une erreur occure
|
|
*
|
|
*/
|
|
public function unlink($params){
|
|
extract($params);
|
|
|
|
/* Suppression de l'association */
|
|
$link_machine = new Repo('machine_cluster/unlink', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_cluster,
|
|
$id_machine
|
|
]);
|
|
|
|
/* (1) On retourne l'erreur du repo */
|
|
return [ 'error' => $link_machine->answer() ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE UNE MACHINE EN FONCTION D'UN MOT CLE
|
|
*
|
|
* @keywords<String> Element de recherche
|
|
*
|
|
* @return machines<Array> Retourne la liste des machines trouvees
|
|
*
|
|
*/
|
|
public function search($params){
|
|
extract($params);
|
|
|
|
// On recupere les donnees
|
|
$machine = new Repo('machine/search', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$keywords
|
|
]);
|
|
|
|
return [ 'machines' => $machine->answer() ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA LISTE EXHAUSTIVE DES MACHINES
|
|
*
|
|
* @return machines<Array> Liste des machines
|
|
*
|
|
*/
|
|
public function getAll(){
|
|
// On recupere les donnees
|
|
$machines = new Repo('machine/getAll', [$_SESSION['WAREHOUSE']['id']]);
|
|
|
|
return [ 'machines' => $machines->answer() ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA MACHINE D'UID DONNE
|
|
*
|
|
* @id_machine<int> UID de la machine en question
|
|
*
|
|
* @return machine<Array> Machine d'UID donne
|
|
*
|
|
*/
|
|
public function getById($params){
|
|
extract($params);
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo('machine/getById', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
// Si aucun resultat, on retourne une erreur
|
|
if( $answer === false )
|
|
return [ 'error' => new Error(Err::NoMatchFound) ];
|
|
|
|
|
|
return [ 'machine' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LA MACHINE DE NAME DONNE
|
|
*
|
|
* @name<String> Name de l'utilisateur en question
|
|
*
|
|
* @return machine<Array> Machine de name donne
|
|
*
|
|
*/
|
|
public function getByName($params){
|
|
extract($params);
|
|
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo('machine/getByName', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$name
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
// Si aucun resultat, on retourne une erreur
|
|
if( $answer === false )
|
|
return [ 'error' => new Error(Err::NoMatchFound) ];
|
|
|
|
|
|
return [ 'machine' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* RENVOIE LES GROUPES D'UNE MACHINE DONNEE
|
|
*
|
|
* @id_machine<int> UID de la machine en question
|
|
*
|
|
* @return clusters<Array> Groupes de la machine donne
|
|
*
|
|
*/
|
|
public function getClusters($params){
|
|
extract($params);
|
|
|
|
// On recupere les donnees
|
|
$request = new Repo('machine/getClusters', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine
|
|
]);
|
|
$answer = $request->answer();
|
|
|
|
// Si aucun resultat, on retourne une erreur
|
|
if( $answer === false )
|
|
return [ 'error' => new Error(Err::NoMatchFound) ];
|
|
|
|
|
|
return [ 'clusters' => $answer ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* MODIFIE UNE MACHINE DONNEE
|
|
*
|
|
* @id_machine<int> UID de la machine
|
|
* @name<String> Identifiant l'utilisateur
|
|
*
|
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien deroule
|
|
*
|
|
*/
|
|
public function edit($params){
|
|
extract($params);
|
|
|
|
|
|
/* [1] On verifie l'existence de la machine
|
|
=========================================================*/
|
|
$machine_exists = new Repo('machine/getById', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine
|
|
]);
|
|
$machine_data = $machine_exists->answer();
|
|
|
|
// Si on a recupere aucune machine, on retourne une erreur
|
|
if( !is_array($machine_data) )
|
|
return ['error' => new Error(Err::NoMatchFound)];
|
|
|
|
|
|
|
|
|
|
/* [2] Normalisation + verification des donnees
|
|
=========================================================*/
|
|
|
|
/* (1) Verification des parametres (si correct et different)*/
|
|
$correct_param = [
|
|
'name' => !is_null($name) && $machine_data['name'] != $name
|
|
];
|
|
|
|
/* (2) Gestion des parametres optionnels */
|
|
$opt_data = [
|
|
'name' => ($correct_param['name']) ? $name : $machine_data['name']
|
|
];
|
|
|
|
|
|
/* [3] Modification de la machine
|
|
=========================================================*/
|
|
$request = new Repo('machine/edit', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine,
|
|
$opt_data['name']
|
|
]);
|
|
|
|
|
|
return [ 'status' => $request->answer() ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* SUPPRIME UNE MACHINE DONNEE
|
|
*
|
|
* @id_machine<int> UID de la machine en question
|
|
*
|
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien deroule
|
|
*
|
|
*/
|
|
public function delete($params){
|
|
extract($params);
|
|
|
|
// On recupere les donnees
|
|
$del_machine = new Repo('machine/delete', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine
|
|
]);
|
|
$deleted_machine = $del_machine->answer();
|
|
|
|
|
|
return [ 'status' => $deleted_machine ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* RETURN MACHINE STATE
|
|
*
|
|
* @id_machine<int> UID of the machine
|
|
*
|
|
* @return state<string> Machine state
|
|
*
|
|
*/
|
|
public function getState($params){
|
|
extract($params);
|
|
|
|
|
|
/* [1] Get machine info
|
|
=========================================================*/
|
|
/* (1) Write request */
|
|
$machine_req = new Request('machineDefault/getById', ['id_machine' => $id_machine]);
|
|
|
|
/* (2) Execute request */
|
|
$machine_res = $machine_req->dispatch();
|
|
|
|
/* (3) Manage error */
|
|
if( $machine_res->error->get() != Err::Success )
|
|
return [ 'error' => $machine_res->error ];
|
|
|
|
/* (4) Fetch data */
|
|
$machine = $machine_res->get('machine');
|
|
|
|
|
|
/* [2] Get action id=>name
|
|
=========================================================*/
|
|
$action = [];
|
|
|
|
/* (1) Write request */
|
|
$action_req = new Repo('action/getAll', []);
|
|
|
|
/* (2) Manage error */
|
|
if( $action_req->error->get() != Err::Success )
|
|
return [ 'error' => $action_req->error ];
|
|
|
|
/* (3) Create association array */
|
|
foreach($action_req->answer() as $a)
|
|
$action[ strtolower($a['name']) ] = $a['id_action'];
|
|
|
|
|
|
/* [3] Get history for the machine
|
|
=========================================================*/
|
|
/* (1) Write request */
|
|
$history_req = new Repo('history/getByIdMachine', [$id_machine]);
|
|
|
|
/* (2) Manage error */
|
|
if( $history_req->error->get() != Err::Success )
|
|
return [ 'error' => $history_req->error ];
|
|
|
|
/* (3) Extract history */
|
|
$history = $history_req->answer();
|
|
|
|
|
|
/* [4] Process state
|
|
=========================================================*/
|
|
|
|
/* (1) IF DETACHED (never initialized)
|
|
---------------------------------------------------------*/
|
|
/* (1) Check machine data (no token | unlock code) */
|
|
if( !$machine['token'] || $machine['unlock_code'] )
|
|
return [ 'state' => 'detached' ];
|
|
|
|
|
|
/* (2) STOPPED (no history)
|
|
---------------------------------------------------------*/
|
|
if( count($history) <= 0 )
|
|
return [ 'state' => 'stopped' ];
|
|
|
|
/* (3) LOCKED (last = lock)
|
|
---------------------------------------------------------*/
|
|
if( $history[0]['id_action'] == $action['lock'] )
|
|
return [ 'state' => 'locked' ];
|
|
|
|
/* (4) STOPPED (last = unlock | stop)
|
|
---------------------------------------------------------*/
|
|
if( in_array($history[0]['id_action'], [$action['stop'], $action['unlock']]) )
|
|
return [ 'state' => 'stopped' ];
|
|
|
|
|
|
/* (5) SIGNALED (start|stop ..... signal)
|
|
---------------------------------------------------------*/
|
|
for( $c = 0 ; $c < count($history) ; $c++ ){
|
|
|
|
/* (1) If (start|stop), continue to search */
|
|
if( in_array($history[$c]['id_action'] , [$action['start'], $action['stop']]) )
|
|
continue;
|
|
|
|
/* (2) If (signal) found, therefore it is signaled */
|
|
else if( $history[$c]['id_action'] == $action['signal'] )
|
|
return [ 'state' => 'signaled' ];
|
|
|
|
/* (6.1) STARTED (last state)
|
|
---------------------------------------------------------*/
|
|
else
|
|
return [ 'state' => 'started' ];
|
|
|
|
}
|
|
|
|
/* (6.2) STARTED (last state)
|
|
---------------------------------------------------------*/
|
|
return [ 'state' => 'started' ];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* ENVOI DES DONNEES D'INITIALISATION DU SYSTEME DES MACHINES
|
|
*
|
|
* @return id_machine<int> UID de la machine
|
|
* @return token<string> Nouveau token d'identification (hashage cyclique)
|
|
* @return unlock<string> Code de déblocage de la machine
|
|
*
|
|
*/
|
|
public function init($params){
|
|
extract($params);
|
|
|
|
|
|
/* [1] On essaie de débloquer la machine
|
|
=========================================================*/
|
|
/* (1) On rédige la requête */
|
|
$unlockReq = new Repo('machine/unlock', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine,
|
|
$unlock,
|
|
$token
|
|
]);
|
|
|
|
/* (2) On gère l'erreur */
|
|
if( $unlockReq->error->get() != Err::Success || !$unlockReq->answer() )
|
|
return [ 'error' => new Error(Err::TokenError) ];
|
|
|
|
|
|
/* [2] On récupére la liste des actions
|
|
=========================================================*/
|
|
$actionsReq = new Repo('action/getAll');
|
|
$actions = ($actionsReq->error->get()==Err::Success) ? $actionsReq->answer() : [];
|
|
// var_dump($actionsReq->answer());
|
|
|
|
|
|
/* [3] On regroupe les actions par TIMEOUT
|
|
=========================================================*/
|
|
$sorted_actions = [];
|
|
|
|
foreach($actions as $a=>$action){
|
|
/* (1) Si aucune valeur pour ce TIMEOUT, on crée un tableau vide */
|
|
if( !isset($sorted_actions[$action['timeout']]) )
|
|
$sorted_actions[$action['timeout']] = [];
|
|
|
|
/* (2) On ajoute l'action au TIMEOUT */
|
|
$sorted_actions[$action['timeout']][] = [
|
|
'id_action' => intval($action['id_action']),
|
|
'name' => strtolower($action['name']),
|
|
'previous' => $action['previous'],
|
|
'action' => $action['action']
|
|
];
|
|
}
|
|
|
|
|
|
/* [4] On récupère la liste des états
|
|
=========================================================*/
|
|
$globalStatesReq = new Repo('global_state/getAll');
|
|
$globalStates = ($globalStatesReq->error->get()==Err::Success) ? $globalStatesReq->answer() : [];
|
|
|
|
|
|
/* [5] On récupère la liste des MODULES (puces)
|
|
=========================================================*/
|
|
$chipsReq = new Repo('chip/getAll', [$_SESSION['WAREHOUSE']['id']]);
|
|
$chips = ($chipsReq->error->get()==Err::Success) ? $chipsReq->answer() : [];
|
|
|
|
|
|
foreach($chips as $c=>$chip){
|
|
/* [5] On récupére la liste des PINS de chaque PUCE
|
|
=========================================================*/
|
|
$pinsReq = new Repo('pin_merge/getByIdChip', [$chip['id_chip']]);
|
|
$pins = ($pinsReq->error->get()==Err::Success) ? $pinsReq->answer() : [];
|
|
|
|
$chips[$c]['pins'] = [];
|
|
foreach($pins as $p=>$pin)
|
|
$chips[$c]['pins'][$p] = intval($pin['pin']);
|
|
|
|
|
|
/* [6] On récupère valeurs pour chaque état de chaque PUCE
|
|
=========================================================*/
|
|
$chips[$c]['states'] = [];
|
|
|
|
$statesReq = new Repo('state/getForChip', [$chip['id_chip']]);
|
|
$states = ($statesReq->error->get()==Err::Success) ? $statesReq->answer() : [];
|
|
|
|
// On met en forme les données : "val1,val2,val3" -> [val1, val2, val3]
|
|
foreach($states as $s=>$state){
|
|
|
|
$chips[$c]['states'][$state['state']] = explode(',', $state['pin_values']);
|
|
foreach($chips[$c]['states'][$state['state']] as $s2=>$state2)
|
|
$chips[$c]['states'][$state['state']][$s2] = intval($state2);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* [6] On récupère les utilisateurs + accès sur la machine
|
|
=========================================================*/
|
|
/* (1) On récupère les utilisateurs et leurs permissions */
|
|
$permissionsReq = new Repo('action_merge/getAccess', [
|
|
$_SESSION['WAREHOUSE']['id'],
|
|
$id_machine
|
|
]);
|
|
$permissions = ($permissionsReq->error->get()==Err::Success) ? $permissionsReq->answer() : [];
|
|
|
|
/* (2) Pour formatte et indexe les permissions par CODE RFID */
|
|
$indexed_permissions = [];
|
|
|
|
foreach($permissions as $p=>$permission){
|
|
$actionList = explode(',', $permission['id_action']);
|
|
|
|
foreach($actionList as $a=>$action)
|
|
$actionList[$a] = intval($action);
|
|
|
|
sort($actionList);
|
|
|
|
$indexed_permissions[$permission['code']] = [
|
|
'id_user' => intval($permission['id_user']),
|
|
'actions' => $actionList
|
|
];
|
|
}
|
|
|
|
|
|
|
|
|
|
/* [N] Retourne les données
|
|
=========================================================*/
|
|
return [
|
|
'actions' => $sorted_actions,
|
|
'states' => $globalStates,
|
|
'chips' => $chips,
|
|
'permissions' => $indexed_permissions
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* SYNCHRONISE UNE MACHINE
|
|
*
|
|
* @token<String> Token de synchronisation de la machine
|
|
* @data<Array> Données de la synchronisation
|
|
* @renew<String> Renouvellement du token de synchronisation de la machine (opt.)
|
|
*
|
|
* @return data<Array> Données de retour de synchronisation
|
|
*
|
|
*/
|
|
public function sync($params){
|
|
extract($params);
|
|
|
|
/* [0] Vérification du token
|
|
=========================================================*/
|
|
$checkToken = new Repo('machine/checkToken', [ $_SESSION['WAREHOUSE']['id'], $token, $renew ]);
|
|
|
|
// Si token incorrect, on envoie une erreur
|
|
if( !$checkToken->answer() )
|
|
return [ 'error' => new Error(Err::TokenError) ];
|
|
|
|
|
|
|
|
/* [1] Initialisation des variables
|
|
=========================================================*/
|
|
$data = ['a', 'b'];
|
|
|
|
|
|
|
|
/* [2] Données à reçues
|
|
=========================================================*/
|
|
|
|
|
|
|
|
/* [3] Données à envoyer
|
|
=========================================================*/
|
|
|
|
|
|
return [
|
|
'data' => $data
|
|
];
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
?>
|