Maj du code de l'exporter + du builder + gestion des dependences (reste à gérer les versions non compatibles) + gestion du reste
This commit is contained in:
xdrm-brackets
parent
ee3be04b09
commit
558ea6b55b
|
|
@ -0,0 +1,64 @@
|
||||||
|
<?php if( !defined('__ROOT__') ) define('__ROOT__', dirname(dirname(__FILE__)) );
|
||||||
|
|
||||||
|
|
||||||
|
class Builder{
|
||||||
|
|
||||||
|
|
||||||
|
private static function src(){ return __ROOT__.'/src'; }
|
||||||
|
private $modules = null;
|
||||||
|
private $root = null;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* BUILDS A BUILDER WITH SPECIFIC LOCATION AND CONFIG
|
||||||
|
*
|
||||||
|
* @pRoot<String> Path to project root
|
||||||
|
* @pModules<Array> Modules to load
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function __construct($pRoot, $pModules){
|
||||||
|
/* [1] Stores the path
|
||||||
|
=========================================================*/
|
||||||
|
$this->root = $pRoot;
|
||||||
|
|
||||||
|
/* [2] Stores the modules
|
||||||
|
=========================================================*/
|
||||||
|
$this->modules = $pModules;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
public function build(){
|
||||||
|
|
||||||
|
/* [1] Builds project's base file structure
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Copy from src/files */
|
||||||
|
shell_exec("cp -r ".__ROOT__."/src/files/* ".$this->root);
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Browse each module to load
|
||||||
|
=========================================================*/
|
||||||
|
foreach($this->modules as $module=>$version){
|
||||||
|
$path = "/$module/$version";
|
||||||
|
|
||||||
|
/* (1) Copy module folder if it exists */
|
||||||
|
if( file_exists(__ROOT__."/src/modules$path/") && is_dir(__ROOT__."/src/modules$path/") && count(scandir(__ROOT__."/src/modules$path/")) > 2 )
|
||||||
|
shell_exec("cp -r ".__ROOT__."/src/modules$path ".$this->root."/build/$module");
|
||||||
|
|
||||||
|
/* (2) Copy module config if it exists */
|
||||||
|
if( file_exists(__ROOT__."/src/config$path/") && is_dir(__ROOT__."/src/config$path/") && count(scandir(__ROOT__."/src/config$path/")) > 2 )
|
||||||
|
shell_exec("cp -r ".__ROOT__."/src/config$path/* ".$this->root."/config/");
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -1,5 +1,7 @@
|
||||||
<?php if( !defined('__ROOT__') ) define('__ROOT__', dirname(dirname(__FILE__)) );
|
<?php if( !defined('__ROOT__') ) define('__ROOT__', dirname(dirname(__FILE__)) );
|
||||||
|
|
||||||
|
require_once 'Builder.php';
|
||||||
|
|
||||||
|
|
||||||
class Exporter{
|
class Exporter{
|
||||||
|
|
||||||
|
|
@ -7,6 +9,9 @@
|
||||||
|
|
||||||
public static function config_path(){ return __ROOT__.'/exporter/modules.json'; }
|
public static function config_path(){ return __ROOT__.'/exporter/modules.json'; }
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* CONSTRUCTOR -> LOADS CONFIG
|
/* CONSTRUCTOR -> LOADS CONFIG
|
||||||
*
|
*
|
||||||
*/
|
*/
|
||||||
|
|
@ -17,6 +22,9 @@
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* RETURNS AVAILABLE MODULE LIST
|
/* RETURNS AVAILABLE MODULE LIST
|
||||||
*
|
*
|
||||||
* @return modules<Array> Set containing modules and their versions
|
* @return modules<Array> Set containing modules and their versions
|
||||||
|
|
@ -29,7 +37,11 @@
|
||||||
$modules[$module] = [];
|
$modules[$module] = [];
|
||||||
|
|
||||||
foreach($versions as $version=>$dependencies)
|
foreach($versions as $version=>$dependencies)
|
||||||
$modules[$module][] = $version;
|
// if version of module enabled
|
||||||
|
if( isset($this->modules['enabled'][$module]) && is_array($this->modules['enabled'][$module]) && in_array($version, $this->modules['enabled'][$module]) )
|
||||||
|
$modules[$module][] = [ 'version' => $version, 'enabled' => true ];
|
||||||
|
else
|
||||||
|
$modules[$module][] = [ 'version' => $version, 'enabled' => false ];
|
||||||
}
|
}
|
||||||
|
|
||||||
return $modules;
|
return $modules;
|
||||||
|
|
@ -65,12 +77,12 @@
|
||||||
/* [2] Version management
|
/* [2] Version management
|
||||||
=========================================================*/
|
=========================================================*/
|
||||||
/* (1) Set default version name & content */
|
/* (1) Set default version name & content */
|
||||||
$vname = array_slice(array_keys($module), -1)[0];
|
$vname = array_slice( array_keys($module), -1 )[0];
|
||||||
$version = $module[$vname];
|
$version = $module[$vname];
|
||||||
|
|
||||||
/* (2) If wrong version given, set to default */
|
/* (2) If wrong version given, set to default */
|
||||||
if( is_null($pVersion) || !isset($module[$pVersion]) )
|
if( is_null($pVersion) || !isset($module[$pVersion]) )
|
||||||
echo "chosing latest $vname version.\n";
|
echo "chosing latest version:\n-----------------------\n [x] $mname:$vname (can throw errors)\n\n";
|
||||||
|
|
||||||
/* (2) Else, we get given @version */
|
/* (2) Else, we get given @version */
|
||||||
else
|
else
|
||||||
|
|
@ -84,14 +96,52 @@
|
||||||
if( !isset($this->modules['enabled'][$mname]) )
|
if( !isset($this->modules['enabled'][$mname]) )
|
||||||
$this->modules['enabled'][$mname] = '0';
|
$this->modules['enabled'][$mname] = '0';
|
||||||
|
|
||||||
/* (2) If not dependency or version lower -> Set version */
|
/* (3) Checks cross version dependency -> trying to enable lower-than-required version of a module*/
|
||||||
|
$crossDep = false;
|
||||||
|
|
||||||
|
// For each available module
|
||||||
|
foreach($this->modules['enabled'] as $xModule=>$xVersion){
|
||||||
|
|
||||||
|
// Loads each module's dependencies
|
||||||
|
if( !isset($this->modules['available'][$xModule][$xVersion]) )
|
||||||
|
continue;
|
||||||
|
|
||||||
|
$xDependencies = $this->modules['available'][$xModule][$xVersion];
|
||||||
|
|
||||||
|
// if module needs a higher version of current module
|
||||||
|
if( isset($xDependencies[$mname]) && $this->lower($this->modules['available'][$mname], $vname, $xDependencies[$mname]) ){
|
||||||
|
$crossDep = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* (4) If trying to load lower than required version -> error */
|
||||||
|
if( $crossDep ){
|
||||||
|
|
||||||
|
// Update module's version
|
||||||
|
if( $this->lower($this->modules['available'][$mname], $this->modules['enabled'][$mname], $xDependencies[$mname]) )
|
||||||
|
$this->modules['enabled'][$mname] = $xDependencies[$mname];
|
||||||
|
|
||||||
|
$this->store();
|
||||||
|
|
||||||
|
return "module `$xModule:$xVersion` needs `$mname:".$xDependencies[$mname]."`\n\naborted.\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* (5) If not a dependency or higher version -> set/update version */
|
||||||
if( !$pDep || $this->lower($module, $this->modules['enabled'][$mname], $vname) ){
|
if( !$pDep || $this->lower($module, $this->modules['enabled'][$mname], $vname) ){
|
||||||
|
|
||||||
if( $pDep ) echo "- $mname-$vname ($vname+ required)\n";
|
// if a dependency, set new params
|
||||||
|
if( $pDep )
|
||||||
|
echo " [x] $mname:$vname (version $vname+ required)\n";
|
||||||
|
|
||||||
|
// else, store new module
|
||||||
$this->modules['enabled'][$mname] = $vname;
|
$this->modules['enabled'][$mname] = $vname;
|
||||||
|
|
||||||
} else if( $pDep ) echo "- $mname-".$this->modules['enabled'][$mname]." ($vname+ required)\n";
|
}else if( $pDep )
|
||||||
|
echo " [x] $mname:".$this->modules['enabled'][$mname]." (version $vname+ required)\n";
|
||||||
|
|
||||||
|
|
||||||
/* [4] Loading dependencies
|
/* [4] Loading dependencies
|
||||||
|
|
@ -181,6 +231,27 @@
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* BUILDS A PROJECT
|
||||||
|
*
|
||||||
|
* @pPath<String> Path to project root
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function build($pPath){
|
||||||
|
$builder = new Builder($pPath, $this->modules['enabled']);
|
||||||
|
|
||||||
|
$builder->build();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* CHECKS IF @pFirst IS LOWER THAN @pSecond VERSION
|
/* CHECKS IF @pFirst IS LOWER THAN @pSecond VERSION
|
||||||
*
|
*
|
||||||
* @pModule<Array> Module's content
|
* @pModule<Array> Module's content
|
||||||
|
|
@ -202,6 +273,9 @@
|
||||||
/* (2) Get @pSecond index */
|
/* (2) Get @pSecond index */
|
||||||
$ps_index = array_search($pSecond, $keys);
|
$ps_index = array_search($pSecond, $keys);
|
||||||
|
|
||||||
|
if( $pf_index === false )
|
||||||
|
return true;
|
||||||
|
|
||||||
return $pf_index < $ps_index;
|
return $pf_index < $ps_index;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -32,7 +32,11 @@
|
||||||
foreach($modules as $module=>$versions){
|
foreach($modules as $module=>$versions){
|
||||||
|
|
||||||
foreach($versions as $version)
|
foreach($versions as $version)
|
||||||
echo " - $module-$version\n";
|
// if enabled
|
||||||
|
if( $version['enabled'] )
|
||||||
|
echo " [x] $module (version ".$version['version'].")\n";
|
||||||
|
else
|
||||||
|
echo " [ ] $module (version ".$version['version'].")\n";
|
||||||
|
|
||||||
echo "\n";
|
echo "\n";
|
||||||
}
|
}
|
||||||
|
|
@ -43,15 +47,15 @@
|
||||||
---------------------------------------------------------*/
|
---------------------------------------------------------*/
|
||||||
case 'enable': {
|
case 'enable': {
|
||||||
|
|
||||||
if( $arglen < 2 || !preg_match("/^(.+)-([0-9\.]+)$/i", $arguments[1], $matches) ){
|
if( $arglen < 2 || !preg_match("/^(.+):([0-9\.-]+)$/i", $arguments[1], $matches) ){
|
||||||
echo "You must specify @module-@version.\n";
|
echo "You must specify @module:@version.\n";
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
$err = $exporter->enable($matches[1], $matches[2]);
|
$err = $exporter->enable($matches[1], $matches[2]);
|
||||||
|
|
||||||
/* (1) Managing state */
|
/* (1) Managing state */
|
||||||
if( $err === true ) echo "success.\n";
|
if( $err === true ) echo "\n\n** success **\n";
|
||||||
else echo $err;
|
else echo $err;
|
||||||
|
|
||||||
} break;
|
} break;
|
||||||
|
|
@ -68,7 +72,27 @@
|
||||||
$err = $exporter->disable($arguments[1]);
|
$err = $exporter->disable($arguments[1]);
|
||||||
|
|
||||||
/* (1) Managing state */
|
/* (1) Managing state */
|
||||||
if( $err === true ) echo "success.\n";
|
if( $err === true ) echo "\n\n** success **\n";
|
||||||
|
else echo $err;
|
||||||
|
|
||||||
|
} break;
|
||||||
|
|
||||||
|
/* (3) Builds a project
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'build': {
|
||||||
|
|
||||||
|
if( $arglen < 2 || !is_dir($arguments[1]) ){
|
||||||
|
echo "You must specify your project root's @path.\n";
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Removes the optional final '/'
|
||||||
|
$arguments[1] = preg_replace('/^(.+)\/$/', '$1', $arguments[1]);
|
||||||
|
|
||||||
|
$err = $exporter->build($arguments[1]);
|
||||||
|
|
||||||
|
/* (1) Managing state */
|
||||||
|
if( $err === true ) echo "\n\n** success **\n";
|
||||||
else echo $err;
|
else echo $err;
|
||||||
|
|
||||||
} break;
|
} break;
|
||||||
|
|
|
||||||
|
|
@ -1,35 +1,43 @@
|
||||||
{
|
{
|
||||||
"available": {
|
"available": {
|
||||||
"error": {
|
"error": {
|
||||||
"1": [],
|
"1.0": [],
|
||||||
"1.2": [],
|
"2.0": []
|
||||||
"1.5": []
|
|
||||||
},
|
},
|
||||||
"api": {
|
"api": {
|
||||||
"0.8": [],
|
"1.0": {
|
||||||
"1": {
|
"error": "1.0"
|
||||||
"error": "1.2"
|
},
|
||||||
|
"2.0": {
|
||||||
|
"error": "2.0"
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"orm": {
|
"orm": {
|
||||||
"0.8": {
|
"0.8-1": {
|
||||||
"database": "1"
|
"database": "1.0"
|
||||||
|
},
|
||||||
|
"0.8-2": {
|
||||||
|
"database": "2.0"
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"database": {
|
"database": {
|
||||||
"1": {
|
"1.0": {
|
||||||
"error": "1"
|
"error": "1.0"
|
||||||
|
},
|
||||||
|
"2.0": {
|
||||||
|
"error": "2.0"
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"lightdb": {
|
"lightdb": {
|
||||||
"1": []
|
"1.0": []
|
||||||
},
|
},
|
||||||
"router": {
|
"router": {
|
||||||
"1": []
|
"1.0": []
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"enabled": {
|
"enabled": {
|
||||||
"api": "1",
|
"orm": "0.8",
|
||||||
"error": "1.2"
|
"database": "1.0",
|
||||||
|
"error": "1.0"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -0,0 +1,60 @@
|
||||||
|
{
|
||||||
|
|
||||||
|
"RESTexample": {
|
||||||
|
"POST::article": {
|
||||||
|
"description": "Posts a new article",
|
||||||
|
"permissions": ["journalist"],
|
||||||
|
"parameters": {
|
||||||
|
"title": { "description": "Article's title", "type": "varchar(5,100)" },
|
||||||
|
"content": { "description": "Article's content", "type": "text" }
|
||||||
|
},
|
||||||
|
"output": {
|
||||||
|
"created_id": { "description": "Id of the created article", "type": "id" }
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
"GET::article": {
|
||||||
|
"description": "Gets all or a specific article",
|
||||||
|
"permissions": ["viewer", "journalist"],
|
||||||
|
"parameters": {
|
||||||
|
"URL_0": { "description": "Article id", "type": "id", "optional": true }
|
||||||
|
},
|
||||||
|
"output": {
|
||||||
|
"articles": { "description": "List of selected articles", "type": "array<mixed>" }
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
"VIEW::article": {
|
||||||
|
"description": "Gets a specific article into a json file (download)",
|
||||||
|
"permissions": ["viewer", "journalist"],
|
||||||
|
"options": { "download": true },
|
||||||
|
"parameters": {
|
||||||
|
"URL_0": { "description": "Article id", "type": "id" }
|
||||||
|
},
|
||||||
|
"output": {
|
||||||
|
"article": { "description": "Selected article as JSON file", "type": "text" }
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
"PUT::article": {
|
||||||
|
"description": "Updates a specific article",
|
||||||
|
"permissions": ["journalist"],
|
||||||
|
"parameters": {
|
||||||
|
"URL_0": { "description": "Article id", "type": "id" },
|
||||||
|
"content": { "description": "Article's content", "type": "text" }
|
||||||
|
},
|
||||||
|
"output": {
|
||||||
|
"article": { "description": "Returns updated article", "type": "array<mixed>" }
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
"DELETE::article": {
|
||||||
|
"description": "Deletes a specific article",
|
||||||
|
"permissions": ["journalist"],
|
||||||
|
"parameters": {
|
||||||
|
"URL_0": { "description": "Article id", "type": "id" }
|
||||||
|
},
|
||||||
|
"output": {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,16 @@
|
||||||
|
{
|
||||||
|
"default": {
|
||||||
|
"local": {
|
||||||
|
"host" : "db_local_host",
|
||||||
|
"dbname" : "db_local_name",
|
||||||
|
"user" : "db_local_user",
|
||||||
|
"password" : "db_local_password"
|
||||||
|
},
|
||||||
|
"remote": {
|
||||||
|
"host" : "db_remote_host",
|
||||||
|
"dbname" : "db_remote_name",
|
||||||
|
"user" : "db_remote_user",
|
||||||
|
"password" : "db_remote_password"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,60 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace api\core;
|
||||||
|
|
||||||
|
use \database\core\Repo;
|
||||||
|
use \error\core\Error;
|
||||||
|
use \error\core\Err;
|
||||||
|
|
||||||
|
class Authentification
|
||||||
|
{
|
||||||
|
|
||||||
|
private static $instance;
|
||||||
|
|
||||||
|
private $userType;
|
||||||
|
private $userId;
|
||||||
|
|
||||||
|
public function __construct()
|
||||||
|
{
|
||||||
|
$token = !empty($_SERVER['PHP_AUTH_DIGEST']) ? $_SERVER['PHP_AUTH_DIGEST'] : false;
|
||||||
|
|
||||||
|
$user = new Repo("AuthentificationRepo/identifyUserByToken", [$token]);
|
||||||
|
$user = $user->answer();
|
||||||
|
|
||||||
|
if( $user != false ){
|
||||||
|
$this->userType = $user["Type"];
|
||||||
|
$this->userId = $user["Id"];
|
||||||
|
}
|
||||||
|
|
||||||
|
new Repo("AuthentificationRepo/updateToken",[$token]);
|
||||||
|
|
||||||
|
new Repo("AuthentificationRepo/purgeOldTokens",[]);
|
||||||
|
|
||||||
|
self::$instance = $this;
|
||||||
|
}
|
||||||
|
|
||||||
|
public function getUserType(){
|
||||||
|
return $this->userType;
|
||||||
|
}
|
||||||
|
|
||||||
|
public function getUserId(){
|
||||||
|
return $this->userId;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static function permission(array $perm){
|
||||||
|
if(in_array(self::$instance->userType,$perm)){
|
||||||
|
return new Error(Err::Success);
|
||||||
|
}
|
||||||
|
|
||||||
|
return new Error(Err::TokenError);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @return Authentification
|
||||||
|
*/
|
||||||
|
public static function getInstance(){
|
||||||
|
return self::$instance;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,150 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace api\core;
|
||||||
|
|
||||||
|
|
||||||
|
class Checker{
|
||||||
|
|
||||||
|
|
||||||
|
/* VERIFICATIONS DES TYPES UTILES GENERIQUES
|
||||||
|
*
|
||||||
|
* @type<String> Type que l'on veut verifier
|
||||||
|
* @value<mixed*> Valeur a verifier
|
||||||
|
*
|
||||||
|
* @return match<Boolean> Retourne si oui ou non la valeur @value est du bon type @type
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function run($type, $value){
|
||||||
|
$checker = true;
|
||||||
|
|
||||||
|
/* [0] On verifie que $value n'est pas nul
|
||||||
|
=========================================================*/
|
||||||
|
if( is_null($value) ) return false;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] Si de type VARCHAR(min, max, flags)
|
||||||
|
=========================================================*/
|
||||||
|
if( preg_match('/^varchar\((\d+), ?(\d+)((?:, ?\w+)+)?\)$/', $type, $match) ){
|
||||||
|
// On recupere la taille min
|
||||||
|
$min = (int) $match[1];
|
||||||
|
// On recupere la taille max
|
||||||
|
$max = (int) $match[2];
|
||||||
|
|
||||||
|
// On recupere le sous-type si défini
|
||||||
|
$flags = isset($match[3]) ? explode(',', substr($match[3], 1)) : null;
|
||||||
|
|
||||||
|
// On effectue la verification de taille
|
||||||
|
$lenCheck = $checker && is_string($value) && strlen($value) <= $max && strlen($value) >= $min;
|
||||||
|
|
||||||
|
// On vérifie les FLAGS s'il est donné
|
||||||
|
if( is_array($flags) )
|
||||||
|
foreach( $flags as $flag )
|
||||||
|
$lenCheck = $lenCheck && self::run($flag, $value);
|
||||||
|
|
||||||
|
return $lenCheck;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Si de type ARRAY(type_elements)
|
||||||
|
=========================================================*/
|
||||||
|
if( preg_match('/^array<(.+)>$/', $type, $match) ){
|
||||||
|
|
||||||
|
// Si c'est pas un tableau on retourne une erreur
|
||||||
|
if( !is_array($value) )
|
||||||
|
return false;
|
||||||
|
|
||||||
|
|
||||||
|
$elements_type = $match[1];
|
||||||
|
|
||||||
|
// On verifie le type pour chaque element
|
||||||
|
foreach($value as $element)
|
||||||
|
// Si erreur dans au moins 1 element, on retourne que c'est incorrect
|
||||||
|
if( !self::run($elements_type, trim($element) ) )
|
||||||
|
return false;
|
||||||
|
|
||||||
|
// Si aucune erreur, on retourne que tout est bon
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [n] Sinon, tous les autres types definis
|
||||||
|
=========================================================*/
|
||||||
|
switch($type){
|
||||||
|
// Quoi que ce soit
|
||||||
|
case 'mixed':
|
||||||
|
return $checker && !is_null($value);
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Entier positif (id dans BDD)
|
||||||
|
case 'id':
|
||||||
|
return $checker && is_numeric($value) && $value <= 2147483647 && $value >= 0;
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Code RFID
|
||||||
|
case 'rfid':
|
||||||
|
return $checker && is_string($value) && preg_match('/^[\dA-F]{2}(\-[\dA-F]{2}){3,5}$/i', $value);
|
||||||
|
break;
|
||||||
|
|
||||||
|
// String quelconque (peut etre vide)
|
||||||
|
case 'text':
|
||||||
|
return $checker && is_string($value);
|
||||||
|
|
||||||
|
// Adresse mail (255 caracteres max)
|
||||||
|
case 'mail':
|
||||||
|
return $checker && is_string($value) && strlen($value) <= 50 && preg_match('/^[\w\.-]+@[\w\.-]+\.[a-z]{2,4}$/i', $value);
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Hash sha1/md5
|
||||||
|
case 'hash':
|
||||||
|
return $checker && is_string($value) && preg_match('/^[\da-f]+$/i', $value) && (strlen($value) == 40 || strlen($value) == 64);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'alphanumeric':
|
||||||
|
return $checker && is_string($value) && preg_match('/^[\w\.-]+$/ui', $value);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'letters':
|
||||||
|
return $checker && is_string($value) && preg_match('/^[a-z -]+$/i', $value);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'status':
|
||||||
|
return $checker && is_numeric($value) && floor($value) == $value && $value >= 0 && $value <= 100;
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Tableau non vide
|
||||||
|
case 'array':
|
||||||
|
return $checker && is_array($value) && count($value) > 0;
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Boolean
|
||||||
|
case 'boolean':
|
||||||
|
return $checker && is_bool($value);
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Objet non vide
|
||||||
|
case 'object':
|
||||||
|
return $checker && is_object($value) && count((array) $value) > 0;
|
||||||
|
break;
|
||||||
|
|
||||||
|
// Chaine JSON (on vérifie via le parser)
|
||||||
|
case 'json':
|
||||||
|
return $checker && is_string($value) && json_decode($value, true) !== NULL;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'numeric':
|
||||||
|
return $checker && (is_numeric($value) || $value == null || $value == 'null');
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
return false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return $checker;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,31 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace api\core;
|
||||||
|
|
||||||
|
|
||||||
|
class ModuleFactory{
|
||||||
|
|
||||||
|
/* INSTANCIE UN MODULE
|
||||||
|
*
|
||||||
|
* @module<String> Nom du module
|
||||||
|
* @arguments<Array> [OPTIONNEL] Arguments à passer au constructeur
|
||||||
|
*
|
||||||
|
* @return instance<Module> Instance du module en question
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function getModule($module, $arguments=[]){
|
||||||
|
/* (1) On gère les arguments */
|
||||||
|
$arguments = is_array($arguments) ? $arguments : [];
|
||||||
|
|
||||||
|
/* (1) On vérifie que la classe existe */
|
||||||
|
if( !file_exists(__BUILD__."/api/module/$module.php") )
|
||||||
|
return false;
|
||||||
|
|
||||||
|
/* (2) On récupère la classe */
|
||||||
|
$class_name = "\\api\\module\\$module";
|
||||||
|
|
||||||
|
/* (3) On retourne une instance */
|
||||||
|
return new $class_name($arguments);
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,581 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace api\core;
|
||||||
|
use \database\core\DatabaseDriver;
|
||||||
|
use \api\core\Authentification;
|
||||||
|
use \api\core\ModuleFactory;
|
||||||
|
use \error\core\Error;
|
||||||
|
use \error\core\Err;
|
||||||
|
|
||||||
|
|
||||||
|
class Request{
|
||||||
|
|
||||||
|
// Constantes
|
||||||
|
public static function config_path(){ return __ROOT__.'/config/modules.json'; }
|
||||||
|
public static $default_options = [
|
||||||
|
'download' => false
|
||||||
|
];
|
||||||
|
|
||||||
|
// Attributs prives utiles (initialisation)
|
||||||
|
private $path;
|
||||||
|
private $params;
|
||||||
|
private $modules;
|
||||||
|
private $options;
|
||||||
|
|
||||||
|
// Contiendra la reponse a la requete
|
||||||
|
public $answer;
|
||||||
|
|
||||||
|
// Contiendra l'etat de la requete
|
||||||
|
public $error;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
|
||||||
|
*
|
||||||
|
* @path<String> Chemin de delegation ("module/methode")
|
||||||
|
* @param<Array> Tableau associatif contenant les parametres utiles au traitement
|
||||||
|
*
|
||||||
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien passe
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function __construct($path=null, $params=null){
|
||||||
|
/* [0] Initialisation
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Erreur par défaut */
|
||||||
|
$this->error = new Error(Err::Success);
|
||||||
|
|
||||||
|
/* (2) Si pas parametre manquant, on quitte */
|
||||||
|
if( $path == null ){
|
||||||
|
$this->error->set(Err::MissingPath);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] On met a jour la configuration
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Section Title */
|
||||||
|
$this->modules = json_decode( file_get_contents(self::config_path()), true );
|
||||||
|
|
||||||
|
/* (2) Gestion de l'erreur de parsage */
|
||||||
|
if( $this->modules == null ){
|
||||||
|
$this->error->set(Err::ParsingFailed, 'json');
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Verification des types des parametres
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Section Title */
|
||||||
|
if( !is_string($path) ){ // Si le type est incorrect
|
||||||
|
$this->error->set(Err::WrongPathModule);
|
||||||
|
return false; // On retourne FALSE, si erreur
|
||||||
|
}
|
||||||
|
|
||||||
|
/* (2) Section Title */
|
||||||
|
$params = (is_array($params)) ? $params : [];
|
||||||
|
|
||||||
|
/* (3) On définit en constante la méthode HTTP */
|
||||||
|
define('__HTTP_METHOD__', strtoupper($_SERVER['REQUEST_METHOD']));
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] Verification du chemin (existence module+methode)
|
||||||
|
=========================================================*/
|
||||||
|
if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
|
||||||
|
return false;
|
||||||
|
|
||||||
|
|
||||||
|
/* [4] Verification des droits
|
||||||
|
=========================================================*/
|
||||||
|
if( !$this->checkPermission() ) // Si on a pas les droits
|
||||||
|
return false;
|
||||||
|
|
||||||
|
|
||||||
|
/* [5] Verification des parametres (si @type est defini)
|
||||||
|
=========================================================*/
|
||||||
|
if( !$this->checkParams($params) ) // Verification de tous les types
|
||||||
|
return false;
|
||||||
|
|
||||||
|
|
||||||
|
/* [6] Récupèration des options
|
||||||
|
=========================================================*/
|
||||||
|
$this->buildOptions();
|
||||||
|
|
||||||
|
|
||||||
|
/* [7] Construction de l'objet
|
||||||
|
=========================================================*/
|
||||||
|
$this->params = $params;
|
||||||
|
$this->error->set(Err::Success);
|
||||||
|
|
||||||
|
return true; // On retourne que tout s'est bien passe
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
|
||||||
|
*
|
||||||
|
* @return answer<Response> Retourne une reponse de type <Response> si tout s'est bien passe
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function dispatch(){
|
||||||
|
/* [0] Si c'est un download, on lance la methode `download()`
|
||||||
|
=========================================================*/
|
||||||
|
if( $this->options['download'] === true )
|
||||||
|
return $this->download();
|
||||||
|
|
||||||
|
/* [1] On verifie qu'aucune erreur n'a ete signalee
|
||||||
|
=========================================================*/
|
||||||
|
if( $this->error->get() !== Err::Success ) // si il y a une erreur
|
||||||
|
return new Response($this->error); // on la passe a la reponse
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] On essaie d'instancier le module
|
||||||
|
=========================================================*/
|
||||||
|
$instance = ModuleFactory::getModule($this->path['module']);
|
||||||
|
|
||||||
|
if( $instance === false ){
|
||||||
|
$this->error->set(Err::UncallableModule, $this->path['module']);
|
||||||
|
return new Response($this->error);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* [3] On verifie que la methode est amorcable
|
||||||
|
=========================================================*/
|
||||||
|
if( !is_callable([$instance, $this->getModuleMethod()]) ){
|
||||||
|
$this->error->set(Err::UncallableMethod, preg_replace('/\w+::/i', '', $this->path['method']) );
|
||||||
|
return new Response($this->error);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [4] On amorce la methode
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On lance la fonction */
|
||||||
|
$returned = call_user_func( [$instance, $this->getModuleMethod()], $this->params );
|
||||||
|
|
||||||
|
/* (2) On appelle le destructeur (si défini) */
|
||||||
|
$instance = null;
|
||||||
|
|
||||||
|
|
||||||
|
/* [5] Gestion de la reponse
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On construit la réponse avec l'erreur */
|
||||||
|
$response = new Response($this->error);
|
||||||
|
|
||||||
|
/* (2) On ajoute les données */
|
||||||
|
$response->appendAll($returned);
|
||||||
|
|
||||||
|
// On retourne la réponse
|
||||||
|
return $response;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* EXECUTE LE TRAITEMENT ASSOCIE ET RENVOIE UN FICHIER AVEC LE HEADER ET LE BODY SPECIFIE
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function download(){
|
||||||
|
/* [1] On verifie qu'aucune erreur n'a ete signalee
|
||||||
|
=========================================================*/
|
||||||
|
if( $this->error->get() !== Err::Success ) // si il y a une erreur
|
||||||
|
return new Response($this->error); // on la passe a la reponse
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] On essaie d'instancier le module
|
||||||
|
=========================================================*/
|
||||||
|
$instance = ModuleFactory::getModule($this->path['module']);
|
||||||
|
|
||||||
|
if( $instance === false ){
|
||||||
|
$this->error->set(Err::UncallableModule);
|
||||||
|
return new Response($this->error);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* [3] On verifie que la methode est amorcable
|
||||||
|
=========================================================*/
|
||||||
|
if( !is_callable([$instance, $this->getModuleMethod()]) ){
|
||||||
|
$this->error->set(Err::UncallableMethod);
|
||||||
|
return new Response($this->error);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [4] On amorce la methode
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On lance la fonction */
|
||||||
|
$returned = call_user_func( [$instance, $this->getModuleMethod()], $this->params );
|
||||||
|
|
||||||
|
/* (2) On appelle le destructeur (si défini) */
|
||||||
|
$instance = null;
|
||||||
|
|
||||||
|
|
||||||
|
/* [5] Vérification des erreurs et paramètres
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Vérification de l'erreur retournée, si pas Success, on retourne l'erreur */
|
||||||
|
if( isset($returned['error']) && $returned['error'] instanceof Error && $returned['error']->get() != Err::Success ){
|
||||||
|
$this->error = $returned['error'];
|
||||||
|
return new Response($this->error);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* (2) Vérification du contenu, si pas défini */
|
||||||
|
if( !isset($returned['body']) ){
|
||||||
|
$this->error->set(Err::ParamError);
|
||||||
|
return new Response($this->error);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* (3) Si @headers n'est pas défini on met par défaut */
|
||||||
|
if( !isset($returned['headers']) || !is_array($returned['headers']) )
|
||||||
|
$returned['headers'] = [];
|
||||||
|
|
||||||
|
$fromAjax = isset($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
|
||||||
|
|
||||||
|
|
||||||
|
/* [6.1] Si requête ajax on crée un fichier temporaire et on renvoie son URL
|
||||||
|
=========================================================*/
|
||||||
|
if( $fromAjax ){
|
||||||
|
|
||||||
|
|
||||||
|
$tmpfname = '/tmp/download_'.uniqid().'.php';
|
||||||
|
$bodyfname = __ROOT__.'/tmp/content_'.uniqid().'.php';
|
||||||
|
|
||||||
|
/* (1) On crée le fichier temporaire */
|
||||||
|
$tmpfnameroot = __ROOT__.$tmpfname;
|
||||||
|
$tmpfile = fopen($tmpfnameroot, 'w');
|
||||||
|
|
||||||
|
fwrite($tmpfile, '<?php'.PHP_EOL);
|
||||||
|
|
||||||
|
/* (2) Script qui écrira les headers */
|
||||||
|
foreach($returned['headers'] as $header=>$value)
|
||||||
|
fwrite($tmpfile, "header(\"$header: $value\");".PHP_EOL);
|
||||||
|
|
||||||
|
/* (3) Script qui écrira le contenu */
|
||||||
|
// 1) On écrit le contenu dans un fichier temporaire (et oui encore)
|
||||||
|
$bodyfile = fopen($bodyfname, 'w');
|
||||||
|
fwrite($bodyfile, $returned['body']);
|
||||||
|
fclose($bodyfile);
|
||||||
|
chmod($bodyfname, 0775);
|
||||||
|
|
||||||
|
fwrite($tmpfile, "readfile('$bodyfname');".PHP_EOL);
|
||||||
|
|
||||||
|
/* (4) Script qui supprimera les fichiers temporaires */
|
||||||
|
fwrite($tmpfile, "unlink('$bodyfname');".PHP_EOL);
|
||||||
|
fwrite($tmpfile, "unlink(__FILE__);".PHP_EOL);
|
||||||
|
|
||||||
|
fwrite($tmpfile, '?>'.PHP_EOL);
|
||||||
|
|
||||||
|
/* (5) On ferme le fichier */
|
||||||
|
fclose($tmpfile);
|
||||||
|
chmod($tmpfnameroot, 0775);
|
||||||
|
|
||||||
|
$response = new Response($this->error);
|
||||||
|
$response->append('link', $tmpfname);
|
||||||
|
|
||||||
|
return $response;
|
||||||
|
|
||||||
|
/* [6.2] Gestion du download direct si pas AJAX
|
||||||
|
=========================================================*/
|
||||||
|
}else{
|
||||||
|
/* (1) On définit les headers */
|
||||||
|
foreach($returned['headers'] as $header=>$value)
|
||||||
|
header($header.': '.$value);
|
||||||
|
|
||||||
|
/* (2) On affiche le contenu */
|
||||||
|
echo $returned['body'];
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* DESERIALISATION A PARTIR DE L'URL ET DES DONNEES POST (OPT)
|
||||||
|
*
|
||||||
|
* @url<String> Contenu de l'url après api/ (si existe)
|
||||||
|
* @post<Array> [opt] Tableau des donnes
|
||||||
|
*
|
||||||
|
* @return instance<Request> Retourne un objet de type <Request>
|
||||||
|
*
|
||||||
|
* @note
|
||||||
|
* 1. `path` peut être dans l'url : /method/module
|
||||||
|
* `path` peut être dans les données $_POST
|
||||||
|
* 2. les données peuvent être dans l'url : /module/method/data1/data2/...
|
||||||
|
* les données peuvent être dans les données $_POST
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function remote($url, $data=null){
|
||||||
|
is_null($data) && ($data = []);
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] On verifie que le @path est renseigne
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Si le path est dans @url */
|
||||||
|
$pathInUrl = count($url) > 0 && is_string($url[0]) && strlen($url[0]) > 0 && preg_match('#^([\w_-]+/[\w_-]+)(?:/?|/((?:\w+/)*(?:\w+/?)))$#', $url[0], $urlMatches);
|
||||||
|
|
||||||
|
/* (2) On récupère le @path + les arguments dans l'URL */
|
||||||
|
if( $pathInUrl ){
|
||||||
|
// {1} On ajoute le @path aux données //
|
||||||
|
$data['path'] = $urlMatches[1];
|
||||||
|
|
||||||
|
// {2} On ajoute les arguments d'URL aux données //
|
||||||
|
if( count($urlMatches) > 2 ){
|
||||||
|
|
||||||
|
$urlParams = explode('/', trim($urlMatches[2], '/'));
|
||||||
|
foreach($urlParams as $k=>$v)
|
||||||
|
$data["URL_$k"] = $v;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* (2) On vérifie dans tous les cas si le path existe */
|
||||||
|
if( !isset($data['path']) )
|
||||||
|
return new Request();
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] On met les paramètres en JSON
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On initialise les paramètres*/
|
||||||
|
$params = [];
|
||||||
|
|
||||||
|
/* (2) On met tous les paramètres en json (sauf @path) */
|
||||||
|
foreach($data as $name=>$value){
|
||||||
|
if( $name === 'path' )
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// {1} On met en JSON //
|
||||||
|
$json = json_decode( $value, true );
|
||||||
|
|
||||||
|
// {2} Si ok -> on remplace //
|
||||||
|
if( !is_null($json) )
|
||||||
|
$params[$name] = $json;
|
||||||
|
|
||||||
|
// {3} Sinon, on laisse tel quel //
|
||||||
|
else
|
||||||
|
$params[$name] = $value;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* [4] On retourne une instance de <Request>
|
||||||
|
=========================================================*/
|
||||||
|
return new Request($data['path'], $params);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE
|
||||||
|
*
|
||||||
|
* @path<String> String correspondant au chemin de delegation ("module/methode")
|
||||||
|
*
|
||||||
|
* @return validity<Boolean> Retourne si oui ou non l'objet est correct
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function checkPath($path){
|
||||||
|
/* [1] Verification format general
|
||||||
|
=========================================================*/
|
||||||
|
if( !preg_match('#^([\w_-]+)/([\w_-]+)$#i', $path, $matches) ){ // Si mauvais format
|
||||||
|
$this->error->set(Err::WrongPathModule);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// On recupere les données de la regex
|
||||||
|
$module = $matches[1];
|
||||||
|
$method = __HTTP_METHOD__.'::'.$matches[2];
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Verification de l'existence du module (conf)
|
||||||
|
=========================================================*/
|
||||||
|
if( !array_key_exists($module, $this->modules) ){ // Si le module n'est pas specifie dans la conf
|
||||||
|
$this->error->set(Err::UnknownModule, $module);
|
||||||
|
return false; // On retourne FALSE, si erreur
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] Verification de l'existence de la methode (conf)
|
||||||
|
=========================================================*/
|
||||||
|
if( array_key_exists($method, $this->modules[$module]) === false ){ // Si la methode n'est pas specifie dans la conf
|
||||||
|
$this->error->set(Err::UnknownMethod, preg_replace('/\w+::/i', '', $method) );
|
||||||
|
return false; // On retourne FALSE, si erreur
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [4] Enregistrement du chemin et renvoi de SUCCESS
|
||||||
|
=========================================================*/
|
||||||
|
$this->path = [
|
||||||
|
'module' => $module,
|
||||||
|
'method' => $method
|
||||||
|
];
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* RETOURNE SI ON A LA PERMISSION D'EXECUTER CETTE METHODE
|
||||||
|
*
|
||||||
|
* @return permission<bool> Retourne si on a les droits ou pas pour executer cette methode
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function checkPermission(){
|
||||||
|
/* [1] On recupere les informations utiles
|
||||||
|
=========================================================*/
|
||||||
|
// On recupere le nom de la methode
|
||||||
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
||||||
|
|
||||||
|
// Si aucune permission n'est definie
|
||||||
|
if( !isset($method['permissions']) ) return true;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Vérification des permissions et de l'authentification
|
||||||
|
=========================================================*/
|
||||||
|
if(!empty($method['permissions'])){
|
||||||
|
$granted = Authentification::permission($method['permissions']);
|
||||||
|
|
||||||
|
/* (1) On retourne FAUX si aucun droit n'a ete trouve */
|
||||||
|
if( $granted->get() !== Err::Success ){
|
||||||
|
$this->error = $granted;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* On retourne VRAI si la permission est ok */
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* VERIFICATION DU TYPE DES PARAMETRES ENVOYES
|
||||||
|
*
|
||||||
|
* @params<Array> Tableau associatif contenant les parametres
|
||||||
|
* @params peut se voir rajouter les paramètres optionnels s'ils ne sont pas renseignés (initialisés à NULL)
|
||||||
|
*
|
||||||
|
* @return correct<bool> Retourne si oui ou non les parametres ont le bon type
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function checkParams(&$params){
|
||||||
|
/* [1] On verifie qu'il ne manque aucun parametre
|
||||||
|
=========================================================*/
|
||||||
|
// Si @params n'est pas un tableau
|
||||||
|
if( !is_array($params) ){
|
||||||
|
$this->error->set(Err::ConfigError);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Si le type est defini, pour chaque param, on teste
|
||||||
|
=========================================================*/
|
||||||
|
foreach($method['parameters'] as $name=>$paramsdata){
|
||||||
|
/* (1) On récupère si le paramètre est optionnel ou pas */
|
||||||
|
$optional = isset($paramsdata['optional']) && $paramsdata['optional'] === true;
|
||||||
|
|
||||||
|
/* (2) Récupère si le paramètre est un fichier et définit comme de type 'FILE' */
|
||||||
|
$isFile = isset($paramsdata['type']) && $paramsdata['type'] == 'FILE' && isset($_FILES[$name]);
|
||||||
|
|
||||||
|
/* (3) Si le paramètre est obligatoire et qu'il n'est pas donné -> erreur */
|
||||||
|
if( !isset($params[$name]) && !$optional && !$isFile ){
|
||||||
|
$this->error->set(Err::MissingParam, $name);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* (4) Si le type n'est pas defini, on a pas besoin de le vérifier */
|
||||||
|
if( !isset($paramsdata['type']) )
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/* (5) Si le paramètre est optionnel et n'est pas donné */
|
||||||
|
if( $isFile || $optional && (!isset($params[$name]) || is_null($params[$name])) ){
|
||||||
|
// On le crée le param optionnel avec la valeur NULL
|
||||||
|
$params[$name] = null;
|
||||||
|
|
||||||
|
// On donne une référence vers le fichier, si c'en est un
|
||||||
|
if( $isFile )
|
||||||
|
$params[$name] = &$_FILES[$name];
|
||||||
|
|
||||||
|
continue; // On passe au paramètre suivant
|
||||||
|
|
||||||
|
|
||||||
|
/* (6) Si le paramètre est renseigné */
|
||||||
|
}else
|
||||||
|
// Si la verification est fausse, on retourne faux
|
||||||
|
if( !Checker::run($paramsdata['type'], $params[$name]) ){
|
||||||
|
$this->error->set(Err::WrongParam, $name, $paramsdata['type']);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
/* [3] Gestion du retour, si tout s'est bien passe
|
||||||
|
=========================================================*/
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* AJOUT DES OPTIONS A PARTIR DE LA CONFIGURATION
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function buildOptions(){
|
||||||
|
/* [0] On récupère les options de la méthode en cours
|
||||||
|
=========================================================*/
|
||||||
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
||||||
|
|
||||||
|
/* (1) Si 'option' n'est pas défini (ou incorrect), on met les valeurs par défaut */
|
||||||
|
if( !isset($method['options']) || !is_array($method['options']) )
|
||||||
|
return true;
|
||||||
|
|
||||||
|
/* (2) Par défaut on définit les options par défaut */
|
||||||
|
$this->options = self::$default_options;
|
||||||
|
|
||||||
|
|
||||||
|
/* (3) On récupère les options données */
|
||||||
|
$options = $method['options'];
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] Gestion des différentes options
|
||||||
|
=========================================================*/
|
||||||
|
foreach($options as $option=>$value){
|
||||||
|
/* (1) On ne prend en compte l'option que si elle est dans les options par défaut */
|
||||||
|
if( !isset(self::$default_options[$option]) )
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/* (2) Le type de la valeur doit être le même que celui de la valeur par défaut */
|
||||||
|
if( gettype($value) != gettype(self::$default_options[$option]) )
|
||||||
|
continue;
|
||||||
|
|
||||||
|
/* (3) Si tout est bon, on définit la valeur */
|
||||||
|
$this->options[$option] = $value;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
|
||||||
|
*
|
||||||
|
* @return method<String> Retourne le chemin d'amorcage de la method
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function getModuleMethod(){
|
||||||
|
/* (1) On essaie de trouver le bon nom */
|
||||||
|
return preg_replace('/\w+::/i', '', $this->path['method']);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,122 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace api\core;
|
||||||
|
use \error\core\Error;
|
||||||
|
use \error\core\Err;
|
||||||
|
|
||||||
|
class Response{
|
||||||
|
|
||||||
|
// Attributs prives utiles (initialisation)
|
||||||
|
private $data;
|
||||||
|
public $error;
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUCTEUR D'UNE REPONSE DE MODULE
|
||||||
|
*
|
||||||
|
* @error<ModuleError> Erreur passee par la requete (si existe)
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function __construct($error=null){
|
||||||
|
if( !( $error instanceof Error ) )
|
||||||
|
$error = new Error(Err::Success);
|
||||||
|
|
||||||
|
$this->data = [];
|
||||||
|
$this->error = $error;
|
||||||
|
}
|
||||||
|
/* AJOUTE UNE DONNEE A LA REPONSE
|
||||||
|
|
||||||
|
|
||||||
|
*
|
||||||
|
* @key<String> Le nom de la valeur a ajouter
|
||||||
|
* @value<mixed*> La valeur a ajouter
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function append($key, $value){
|
||||||
|
// Ajoute une entree pour la cle @key et de valeur @value
|
||||||
|
$this->data[$key] = $value;
|
||||||
|
|
||||||
|
return $this;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* AJOUTE TOUTES LES DONNEES A LA REPONSE
|
||||||
|
*
|
||||||
|
* @dataset<Array> Le tableau associatif correspondant a la reponse
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function appendAll($dataset){
|
||||||
|
// Si ce n'est pas un tableau, on ne fais rien
|
||||||
|
if( !is_array($dataset) )
|
||||||
|
return $this;
|
||||||
|
|
||||||
|
// Si une valeur contient une erreur
|
||||||
|
if( array_key_exists('error', $dataset) && $dataset['error'] instanceof Error){
|
||||||
|
// On definit cette erreur
|
||||||
|
$this->error = $dataset['error'];
|
||||||
|
// On enleve cette entree des donnees
|
||||||
|
unset($dataset['error']);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ajoute une entree pour la cle @key et de valeur @value
|
||||||
|
$this->data = $dataset;
|
||||||
|
|
||||||
|
return $this;
|
||||||
|
}
|
||||||
|
/* RECUPERE UNE DONNEE DE LA REPONSE
|
||||||
|
|
||||||
|
|
||||||
|
*
|
||||||
|
* @key<String> Le nom de la valeur a recuperer
|
||||||
|
*
|
||||||
|
* @return value<mixed*> La valeur a cette cle
|
||||||
|
* @return error<null> Retourne NULL si aucune valeur pour cette cle
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function get($key){
|
||||||
|
// Si la valeur de cle @key n'existe pas, on retourne NULL
|
||||||
|
if( !isset($this->data[$key]) )
|
||||||
|
return null;
|
||||||
|
|
||||||
|
// Sinon, on retourne la valeur associee
|
||||||
|
return $this->data[$key];
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* RECUPERE TOUTES LES DONNEES DE LA REPONSE
|
||||||
|
*
|
||||||
|
* @return data<Array> Les donnees de la reponse
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function getAll(){
|
||||||
|
// Sinon, on retourne la valeur associee
|
||||||
|
return $this->data;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* SERIALISATION A PARTIR DES DONNEES
|
||||||
|
*
|
||||||
|
* @return json<String> Retourne les donnees serialisees
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function serialize(){
|
||||||
|
|
||||||
|
// Code Http
|
||||||
|
$this->error->setHttpCode();
|
||||||
|
|
||||||
|
// Type de contenu
|
||||||
|
header('Content-Type: application/json; charset=utf-8');
|
||||||
|
|
||||||
|
// On rajoute l'erreur au message
|
||||||
|
$returnData = array_merge([
|
||||||
|
'error' => $this->error->get(),
|
||||||
|
'ErrorDescription' => $this->error->explicit()
|
||||||
|
],
|
||||||
|
$this->data
|
||||||
|
);
|
||||||
|
|
||||||
|
return json_encode($returnData);
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,116 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace api\module;
|
||||||
|
|
||||||
|
|
||||||
|
use error\core\Error;
|
||||||
|
use error\core\Err;
|
||||||
|
|
||||||
|
class RESTexample{
|
||||||
|
|
||||||
|
public function __construct(){
|
||||||
|
// Routine to execute before each call to RESTexample's method
|
||||||
|
}
|
||||||
|
|
||||||
|
public function __destruct(){
|
||||||
|
// Routine to execute after each call to RESTexample's method
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
public function article($argv){
|
||||||
|
extract($argv);
|
||||||
|
|
||||||
|
switch(__HTTP_METHOD__){
|
||||||
|
case 'POST':
|
||||||
|
// POST a new article with variables:
|
||||||
|
$title; // new article's title
|
||||||
|
$content; // new article's content
|
||||||
|
|
||||||
|
// ...
|
||||||
|
// process to create article and get $output_created_id
|
||||||
|
// ...
|
||||||
|
|
||||||
|
if( !$success )
|
||||||
|
return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
|
||||||
|
|
||||||
|
return ['created_id' => $output_created_id];
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'GET':
|
||||||
|
// GET all/an article with the variable:
|
||||||
|
$URL_0; // id of article ; if not given -> null
|
||||||
|
|
||||||
|
// ...
|
||||||
|
// process to get articles and get $output_get_articles
|
||||||
|
// ...
|
||||||
|
|
||||||
|
if( !$success )
|
||||||
|
return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
|
||||||
|
|
||||||
|
return ['articles' => $output_get_articles];
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'VIEW':
|
||||||
|
// VIEW a specific article (download json file) with the variable:
|
||||||
|
$URL_0; // id of article ; if not given -> null
|
||||||
|
|
||||||
|
// ...
|
||||||
|
// process to get articles and get $output_get_articles
|
||||||
|
// ...
|
||||||
|
|
||||||
|
if( !$success )
|
||||||
|
return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
|
||||||
|
|
||||||
|
// will download, but if AJAX will give a `link` to the file
|
||||||
|
return [
|
||||||
|
'headers' => [
|
||||||
|
'Content-Type' => 'application/json; charset=utf-8',
|
||||||
|
'Content-Disposition' => 'attachment; filename=export'.date('_d_m_Y', time()).'.json',
|
||||||
|
'Pragma' => 'no-cache',
|
||||||
|
'Expires' => '0'
|
||||||
|
],
|
||||||
|
'body' => json_encode($output_get_articles)
|
||||||
|
];
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'PUT':
|
||||||
|
// UPDATE an article with new content with variables:
|
||||||
|
$URL_0; // id of article to update
|
||||||
|
$title; // new article's title
|
||||||
|
$content; // new article's content
|
||||||
|
|
||||||
|
// ...
|
||||||
|
// process to get $output_updated_article
|
||||||
|
// ...
|
||||||
|
|
||||||
|
if( !$success )
|
||||||
|
return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
|
||||||
|
|
||||||
|
return ['article' => $output_updated_article];
|
||||||
|
break;
|
||||||
|
|
||||||
|
case 'DELETE':
|
||||||
|
// DELETEs an article with the variable:
|
||||||
|
$URL_0; // id of the article to remove
|
||||||
|
|
||||||
|
// ...
|
||||||
|
// process to delete article
|
||||||
|
// ...
|
||||||
|
|
||||||
|
if( !$success )
|
||||||
|
return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
|
||||||
|
|
||||||
|
return []; // returns success
|
||||||
|
break;
|
||||||
|
|
||||||
|
// if no match -> error
|
||||||
|
default:
|
||||||
|
return ['error' => new Error(Err::UnknownHttpMethod)];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,180 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace database\core;
|
||||||
|
use \error\core\Error;
|
||||||
|
use \error\core\Err;
|
||||||
|
|
||||||
|
|
||||||
|
class DatabaseDriver{
|
||||||
|
|
||||||
|
/* STATIC ATTRIBUTES */
|
||||||
|
private static function conf(){
|
||||||
|
// YOUR CONFIGURATION BEHIND
|
||||||
|
$path = __CONFIG__.'/database-driver.json';
|
||||||
|
|
||||||
|
/* (1) Checks the file */
|
||||||
|
if( !is_file($path) )
|
||||||
|
return [];
|
||||||
|
|
||||||
|
/* (2) Checks json */
|
||||||
|
$parsed = json_decode( file_get_contents($path), true );
|
||||||
|
|
||||||
|
if( !is_array($parsed) )
|
||||||
|
return [];
|
||||||
|
|
||||||
|
/* (3) Returns configuration */
|
||||||
|
return $parsed;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
private static $path; // Databases configurations files
|
||||||
|
private static $config; // PDO configurations
|
||||||
|
private static $instance = []; // Database driver instance list
|
||||||
|
|
||||||
|
public $error;
|
||||||
|
|
||||||
|
/* ATTRIBUTES */
|
||||||
|
private $host;
|
||||||
|
private $dbname;
|
||||||
|
private $username;
|
||||||
|
private $password;
|
||||||
|
private $pdo;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUCTOR OF A DATABASE DRIVER
|
||||||
|
*
|
||||||
|
* @host<String> Database Server's host
|
||||||
|
* @dbname<String> Database name
|
||||||
|
* @username<String> Database username
|
||||||
|
* @password<String> Database password
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function __construct($host, $dbname, $username, $password){
|
||||||
|
/* (2) Stores configuration */
|
||||||
|
$this->host = $host;
|
||||||
|
$this->dbname = $dbname;
|
||||||
|
$this->username = $username;
|
||||||
|
$this->password = $password;
|
||||||
|
|
||||||
|
try{
|
||||||
|
|
||||||
|
$this->pdo = new \PDO('mysql:host='.$this->host.';dbname='.$this->dbname, $this->username, $this->password);
|
||||||
|
$this->pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC);
|
||||||
|
|
||||||
|
// On signale que tout s'est bien passe
|
||||||
|
$this->error = new Error(Err::Success);
|
||||||
|
|
||||||
|
}catch(Exception $e){
|
||||||
|
// On signale qu'il y a une erreur
|
||||||
|
$this->error = new Error(Err::PDOConnection);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/************************************************
|
||||||
|
**** Multiton Management (static) ****
|
||||||
|
************************************************/
|
||||||
|
|
||||||
|
/* ADDS A NEW CONNECTION
|
||||||
|
*
|
||||||
|
* @label<String> [optional] Database Label
|
||||||
|
*
|
||||||
|
* @return status<Boolean> If added successfully
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private static function add($label=null){
|
||||||
|
$conf = self::conf();
|
||||||
|
|
||||||
|
/* [1] Default values
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) If label isn't given */
|
||||||
|
is_null($label) && ($label = 'default');
|
||||||
|
|
||||||
|
/* (2) If label and no path */
|
||||||
|
if( $label !== 'default' && !isset($conf[$label]) )
|
||||||
|
return false;
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] Instanciates the driver
|
||||||
|
=========================================================*/
|
||||||
|
try{
|
||||||
|
|
||||||
|
/* (1) If local -> instanciates with local configuration */
|
||||||
|
if( !checkdnsrr($_SERVER['SERVER_NAME'], 'NS') )
|
||||||
|
self::$instance[$label] = new DatabaseDriver($conf[$label]['local']['host'], $conf[$label]['local']['dbname'], $conf[$label]['local']['user'], $conf[$label]['local']['password']);
|
||||||
|
/* (2) If Remote -> instanciates with Remote configuration */
|
||||||
|
else
|
||||||
|
self::$instance[$label] = new DatabaseDriver($conf[$label]['remote']['host'], $conf[$label]['remote']['dbname'], $conf[$label]['remote']['user'], $conf[$label]['remote']['password']);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
|
||||||
|
}catch(\Exception $e){
|
||||||
|
|
||||||
|
/* (3) If fails */
|
||||||
|
return false;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* GET A DATABASE DRIVER INSTANCE
|
||||||
|
*
|
||||||
|
* @label<String> [optional] Driver's label
|
||||||
|
*
|
||||||
|
* @return driver<Database> Multiton
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function get($label=null){
|
||||||
|
$conf = self::conf();
|
||||||
|
|
||||||
|
/* [1] Checks arguments
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Label default value */
|
||||||
|
is_null($label) && ($label = 'default');
|
||||||
|
|
||||||
|
/* (2) If no label, or unknown label */
|
||||||
|
if( is_null($label) || !isset(self::$instance[$label]) ){
|
||||||
|
|
||||||
|
/* (2.1) Try to add the configuration if exists */
|
||||||
|
if( isset($conf[$label]) ){
|
||||||
|
self::add($label);
|
||||||
|
return self::get($label);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
throw new \Exception('Database @label is incorrect.');
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Returns instance
|
||||||
|
=========================================================*/
|
||||||
|
return self::$instance[$label];
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/** retourne la connection statique
|
||||||
|
* @param null $label
|
||||||
|
* @return \PDO
|
||||||
|
*/
|
||||||
|
public static function getPDO($label=null){
|
||||||
|
$instance = self::get($label);
|
||||||
|
|
||||||
|
return $instance->pdo;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
public function getConfig(){
|
||||||
|
return [
|
||||||
|
'host' => $this->host,
|
||||||
|
'dbname' => $this->dbname,
|
||||||
|
'username' => $this->username
|
||||||
|
];
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,193 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace database\core;
|
||||||
|
|
||||||
|
use \error\core\Error;
|
||||||
|
use \error\core\Err;
|
||||||
|
use \api\core\Authentification;
|
||||||
|
|
||||||
|
|
||||||
|
class Repo{
|
||||||
|
|
||||||
|
// Constantes
|
||||||
|
public static function config_path(){ return __ROOT__.'/config/repositories.json'; }
|
||||||
|
|
||||||
|
|
||||||
|
// Attributs prives utiles (initialisation)
|
||||||
|
private $path;
|
||||||
|
private $params; // Paramètres de la requête
|
||||||
|
private $repositories;
|
||||||
|
|
||||||
|
// Contiendra la reponse a la requete
|
||||||
|
private $answer;
|
||||||
|
|
||||||
|
// Contiendra l'etat de la requete
|
||||||
|
public $error;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
|
||||||
|
*
|
||||||
|
* @path<String> Chemin de delegation ("repo/methode")
|
||||||
|
* @params<Array> Tableau contenant les parametres utiles au traitement
|
||||||
|
*
|
||||||
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien passe
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function __construct($path=null, $params=null){
|
||||||
|
|
||||||
|
// Si pas parametre manquant, on quitte
|
||||||
|
if( $path == null ){
|
||||||
|
$this->error = new Error(Err::MissingPath);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* [0] On met a jour la configuration
|
||||||
|
=========================================================*/
|
||||||
|
// Modules specifies
|
||||||
|
$this->repositories = json_decode( file_get_contents(self::config_path()), true );
|
||||||
|
|
||||||
|
// Gestion de l'erreur de parsage
|
||||||
|
if( $this->repositories == null ){
|
||||||
|
$this->error = new Error(Err::ParsingFailed, 'json');
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] Verification des types des parametres
|
||||||
|
=========================================================*/
|
||||||
|
// Type de @path
|
||||||
|
if( !is_string($path) ){ // Si le type est incorrect
|
||||||
|
$this->error = new Error(Err::WrongPathRepo);
|
||||||
|
return false; // On retourne FALSE, si erreur
|
||||||
|
}
|
||||||
|
|
||||||
|
// Type de @params (optionnel)
|
||||||
|
$params = (is_array($params)) ? $params : [];
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Verification du chemin (existence repo+methode)
|
||||||
|
=========================================================*/
|
||||||
|
if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
|
||||||
|
return false;
|
||||||
|
// Gestion d'erreur interne
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] Construction de l'objet
|
||||||
|
=========================================================*/
|
||||||
|
$this->params = $params;
|
||||||
|
$this->error = new Error(Err::Success);
|
||||||
|
|
||||||
|
/* [4] Enregistrement de la reponse
|
||||||
|
=========================================================*/
|
||||||
|
$this->answer = $this->dispatch();
|
||||||
|
|
||||||
|
|
||||||
|
return true; // On retourne que tout s'est bien passe
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
public function answer(){
|
||||||
|
if( $this->error->get() !== Err::Success )
|
||||||
|
return false;
|
||||||
|
|
||||||
|
return $this->answer;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
|
||||||
|
*
|
||||||
|
* @return answer<mixed*> Retourne une reponse, si tout s'est bien passe
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function dispatch(){
|
||||||
|
/* [1] On verifie qu'aucune erreur n'a ete signalee
|
||||||
|
=========================================================*/
|
||||||
|
if( $this->error->get() !== Err::Success ) // si il y a une erreur
|
||||||
|
return false; // on la passe a la reponse
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] On verifie que la methode est amorcable
|
||||||
|
=========================================================*/
|
||||||
|
if( !is_callable($this->getFunctionCaller()) ){
|
||||||
|
$this->error = new Error(Err::UncallableMethod, $this->path['method']);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] On amorce la methode
|
||||||
|
=========================================================*/
|
||||||
|
return call_user_func_array( $this->getFunctionCaller(), $this->params );
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE
|
||||||
|
*
|
||||||
|
* @path<String> String correspondant au chemin de delegation ("repo/methode")
|
||||||
|
*
|
||||||
|
* @return validity<Boolean> Retourne si oui ou non l'objet est correct
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function checkPath($path){
|
||||||
|
/* [1] Verification format general
|
||||||
|
=========================================================*/
|
||||||
|
if( !preg_match('#^([\w_-]+)/([\w_-]+)$#i', $path, $matches) ){ // Si mauvais format
|
||||||
|
$this->error = new Error(Err::WrongPathRepo);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// On recupere les donnes de la regex
|
||||||
|
$repository = $matches[1];
|
||||||
|
$method = $matches[2];
|
||||||
|
|
||||||
|
/* [2] Verification de l'existence du repo (conf)
|
||||||
|
=========================================================*/
|
||||||
|
if( !array_key_exists($repository, $this->repositories) ){ // Si le repo n'est pas specifie dans la conf
|
||||||
|
$this->error = new Error(Err::UnknownRepo, $repository);
|
||||||
|
return false; // On retourne FALSE, si erreur
|
||||||
|
}
|
||||||
|
|
||||||
|
/* [3] Verification de l'existence de la methode (conf)
|
||||||
|
=========================================================*/
|
||||||
|
if( array_search($method, $this->repositories[$repository]) === false ){ // Si la methode n'est pas specifie dans la conf
|
||||||
|
$this->error = new Error(Err::UnknownMethod, $method);
|
||||||
|
return false; // On retourne FALSE, si erreur
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [4] Enregistrement du chemin et renvoi de SUCCESS
|
||||||
|
=========================================================*/
|
||||||
|
$this->path = [
|
||||||
|
'repo' => $repository,
|
||||||
|
'method' => $method
|
||||||
|
];
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
|
||||||
|
*
|
||||||
|
* @return path<Array> Retourne le chemin d'amorcage de la requete
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
private function getFunctionCaller(){
|
||||||
|
return [ '\\database\\repo\\'.$this->path['repo'], $this->path['method'] ];
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,109 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
|
||||||
|
namespace error\core;
|
||||||
|
|
||||||
|
|
||||||
|
class Err{
|
||||||
|
/* [1] Success
|
||||||
|
=========================================================*/
|
||||||
|
const Success = 0;
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Fichiers / Ressources
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Parsage json/xml */
|
||||||
|
const ParsingFailed = 1;
|
||||||
|
/* (2) Fichier inexistant */
|
||||||
|
const UnreachableResource = 2;
|
||||||
|
/* (3) Erreur d'upload */
|
||||||
|
const UploadError = 3;
|
||||||
|
/* (4) Mauvais format de fichier */
|
||||||
|
const FormatError = 4;
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] Permissions
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Token inexistant ou incorrect */
|
||||||
|
const TokenError = 5;
|
||||||
|
/* (2) Permission non autorisée */
|
||||||
|
const PermissionError = 6;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [4] API
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Le module n'est pas activé */
|
||||||
|
const DisabledModule = 7;
|
||||||
|
|
||||||
|
/* (2) Le @path n'est pas renseigne */
|
||||||
|
const MissingPath = 8;
|
||||||
|
/* (3) Verification de la coherence du chemin (existe dans la conf) */
|
||||||
|
const WrongPathModule = 9;
|
||||||
|
|
||||||
|
/* (4) Module non specifie dans la conf */
|
||||||
|
const UnknownModule = 10;
|
||||||
|
/* (5) Methode non specifie pour ce Module dans la conf */
|
||||||
|
const UnknownMethod = 11;
|
||||||
|
|
||||||
|
/* (6) Module non amorcable */
|
||||||
|
const UncallableModule = 12;
|
||||||
|
/* (7) Methode non amorcable */
|
||||||
|
const UncallableMethod = 13;
|
||||||
|
|
||||||
|
/* (8) Erreur méthode HTTP */
|
||||||
|
const UnknownHttpMethod = 14;
|
||||||
|
|
||||||
|
/* (9) Erreur de configuration */
|
||||||
|
const ConfigError = 15;
|
||||||
|
/* (10) Paramètre manquant */
|
||||||
|
const MissingParam = 16;
|
||||||
|
/* (11) Paramètre incorrect */
|
||||||
|
const WrongParam = 17;
|
||||||
|
/* (12) Erreur dans le traitement */
|
||||||
|
const ModuleError = 18;
|
||||||
|
|
||||||
|
|
||||||
|
/* [5] Database
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Base de données
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
/* (1) Erreur lors de la creation d'un objet PDO (connection) */
|
||||||
|
const PDOConnection = 19;
|
||||||
|
|
||||||
|
/* (2) Repositories
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
/* (1) Verification de la coherence du chemin (existe dans la conf) */
|
||||||
|
const WrongPathRepo = 20;
|
||||||
|
|
||||||
|
/* (2) Module non specifie dans la conf */
|
||||||
|
const UnknownRepo = 21;
|
||||||
|
|
||||||
|
/* (3) Erreur dans le traitement */
|
||||||
|
const RepoError = 22;
|
||||||
|
|
||||||
|
/* (3) ORM
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
/* (1) Table n'existe pas */
|
||||||
|
const UnknownTable = 23;
|
||||||
|
/* (2) Pas permissions de lire le schéma */
|
||||||
|
const NotAllowedSchema = 24;
|
||||||
|
|
||||||
|
|
||||||
|
/* [6] Erreurs diverses
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Aucune donnée trouvée */
|
||||||
|
const NoMatchFound = 25;
|
||||||
|
|
||||||
|
/* (2) Mauvais chemin de template */
|
||||||
|
const UnknownTemplate = 26;
|
||||||
|
|
||||||
|
/* (3) géolocalisation échouée */
|
||||||
|
const UnknownAddress = 27;
|
||||||
|
|
||||||
|
/* (4) Erreur inconnue */
|
||||||
|
const UnknownError = 28;
|
||||||
|
}
|
||||||
|
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,191 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
|
||||||
|
namespace error\core;
|
||||||
|
|
||||||
|
use \error\core\Err;
|
||||||
|
|
||||||
|
class Error{
|
||||||
|
|
||||||
|
private $error = null;
|
||||||
|
private $arguments = [];
|
||||||
|
|
||||||
|
/* ERROR CONSTRUCTOR
|
||||||
|
*
|
||||||
|
* @error<const> Const error
|
||||||
|
* @arg1<String> [OPT] Argument 1
|
||||||
|
* @arg2<String> [OPT] Argument 2
|
||||||
|
* @arg...<String> [OPT] Argument ...
|
||||||
|
*
|
||||||
|
* @return instance<Error> Error instance
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function __construct($const){
|
||||||
|
call_user_func_array([$this, 'set'], func_get_args());
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ERROR GETTER
|
||||||
|
*
|
||||||
|
* @return Err<Err::Constant> Error
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function get(){ return $this->error; }
|
||||||
|
|
||||||
|
/* ERROR SETTER
|
||||||
|
*
|
||||||
|
* @error<const> Const error
|
||||||
|
* @arg1<String> [OPT] Argument 1
|
||||||
|
* @arg2<String> [OPT] Argument 2
|
||||||
|
* @arg...<String> [OPT] Argument ...
|
||||||
|
*
|
||||||
|
* @return instance<Error> Error instance
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function set($const){
|
||||||
|
/* [1] On découpe les arguments
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On récupère l'erreur */
|
||||||
|
$this->error = !is_numeric($const) ? Err::UnknownError : $const;
|
||||||
|
|
||||||
|
/* (2) On récupère les arguments */
|
||||||
|
$this->arguments = array_slice(func_get_args(), 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* EXPLICITE UN CODE D'ERREUR
|
||||||
|
*
|
||||||
|
* @return explicit<String> Description explicite du code d'erreur
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public function explicit(){
|
||||||
|
switch($this->error){
|
||||||
|
case Err::Success: return $this->Success(); break;
|
||||||
|
case Err::ParsingFailed: return $this->ParsingFailed(); break;
|
||||||
|
case Err::UnreachableResource: return $this->UnreachableResource(); break;
|
||||||
|
case Err::UploadError: return $this->UploadError(); break;
|
||||||
|
case Err::FormatError: return $this->FormatError(); break;
|
||||||
|
case Err::TokenError: return $this->TokenError(); break;
|
||||||
|
case Err::PermissionError: return $this->PermissionError(); break;
|
||||||
|
case Err::DisabledModule: return $this->DisabledModule(); break;
|
||||||
|
case Err::MissingPath: return $this->MissingPath(); break;
|
||||||
|
case Err::WrongPathModule: return $this->WrongPathModule(); break;
|
||||||
|
case Err::UnknownModule: return $this->UnknownModule(); break;
|
||||||
|
case Err::UnknownMethod: return $this->UnknownMethod(); break;
|
||||||
|
case Err::UncallableModule: return $this->UncallableModule(); break;
|
||||||
|
case Err::UncallableMethod: return $this->UncallableMethod(); break;
|
||||||
|
case Err::UnknownHttpMethod: return $this->UnknownHttpMethod(); break;
|
||||||
|
case Err::ConfigError: return $this->ConfigError(); break;
|
||||||
|
case Err::MissingParam: return $this->MissingParam(); break;
|
||||||
|
case Err::WrongParam: return $this->WrongParam(); break;
|
||||||
|
case Err::ModuleError: return $this->ModuleError(); break;
|
||||||
|
case Err::PDOConnection: return $this->PDOConnection(); break;
|
||||||
|
case Err::WrongPathRepo: return $this->WrongPathRepo(); break;
|
||||||
|
case Err::UnknownRepo: return $this->UnknownRepo(); break;
|
||||||
|
case Err::RepoError: return $this->RepoError(); break;
|
||||||
|
case Err::UnknownTable: return $this->UnknownTable(); break;
|
||||||
|
case Err::NotAllowedSchema: return $this->NotAllowedSchema(); break;
|
||||||
|
case Err::NoMatchFound: return $this->NoMatchFound(); break;
|
||||||
|
case Err::UnknownTemplate: return $this->UnknownTemplate(); break;
|
||||||
|
case Err::UnknownAddress: return $this->UnknownAddress(); break;
|
||||||
|
case Err::UnknownError: return $this->UnknownError(); break;
|
||||||
|
|
||||||
|
default: return $this->UnknownDebugError(); break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
private function Success(){
|
||||||
|
return 'all right';
|
||||||
|
}private function ParsingFailed(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
return $this->arguments[0].' parsing failed';
|
||||||
|
else
|
||||||
|
return 'parsing failed';
|
||||||
|
}private function UnreachableResource(){
|
||||||
|
return 'unreachable resource';
|
||||||
|
}private function UploadError(){
|
||||||
|
return 'upload error';
|
||||||
|
}private function FormatError(){
|
||||||
|
return 'format error';
|
||||||
|
}private function TokenError(){
|
||||||
|
return 'bad or expired token';
|
||||||
|
}private function PermissionError(){
|
||||||
|
return 'permission error';
|
||||||
|
}private function DisabledModule(){
|
||||||
|
return 'disabled module';
|
||||||
|
}private function MissingPath(){
|
||||||
|
return 'missing path';
|
||||||
|
}private function WrongPathModule(){
|
||||||
|
return 'wrong module\'s path';
|
||||||
|
}private function UnknownModule(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
return 'unknown module \''.$this->arguments[0].'\'';
|
||||||
|
else
|
||||||
|
return 'unknown module';
|
||||||
|
}private function UnknownMethod(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
return 'unknown method \''.$this->arguments[0].'\'';
|
||||||
|
else
|
||||||
|
return 'unknown method';
|
||||||
|
}private function UncallableModule(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
return 'uncallable module \''.$this->arguments[0].'\'';
|
||||||
|
else
|
||||||
|
return 'uncallable module';
|
||||||
|
}private function UncallableMethod(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
return 'uncallable method \''.$this->arguments[0].'\'';
|
||||||
|
else
|
||||||
|
return 'uncallable method';
|
||||||
|
}private function UnknownHttpMethod(){
|
||||||
|
return 'unknown HTTP method';
|
||||||
|
}private function ConfigError(){
|
||||||
|
return 'configuration error';
|
||||||
|
}private function MissingParam(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
return 'missing param \''.$this->arguments[0].'\'';
|
||||||
|
else
|
||||||
|
return 'missing param';
|
||||||
|
}private function WrongParam(){
|
||||||
|
if( count($this->arguments) > 0 )
|
||||||
|
if( count($this->arguments) > 1 )
|
||||||
|
return 'wrong param \''.$this->arguments[0].'\' expected to be of type \''.$this->arguments[1].'\'';
|
||||||
|
else
|
||||||
|
return 'wrong param \''.$this->arguments[0].'\'';
|
||||||
|
else
|
||||||
|
return 'wrong param';
|
||||||
|
}private function ModuleError(){
|
||||||
|
return 'module error';
|
||||||
|
}private function PDOConnection(){
|
||||||
|
return 'database error';
|
||||||
|
}private function WrongPathRepo(){
|
||||||
|
return 'wrong repository\'s path';
|
||||||
|
}private function UnknownRepo(){
|
||||||
|
return 'unknown repository';
|
||||||
|
}private function RepoError(){
|
||||||
|
return 'repository error';
|
||||||
|
}private function UnknownTable(){
|
||||||
|
return 'unknown table';
|
||||||
|
}private function NotAllowedSchema(){
|
||||||
|
return 'schema browsing not allowed';
|
||||||
|
}private function NoMatchFound(){
|
||||||
|
return 'no match found';
|
||||||
|
}private function UnknownTemplate(){
|
||||||
|
return 'unknown template';
|
||||||
|
}private function UnknownAddress(){
|
||||||
|
return 'unknown';
|
||||||
|
}private function UnknownError(){
|
||||||
|
return 'unknown error';
|
||||||
|
}private function UnknownDebugError(){
|
||||||
|
return 'unknown debug error';
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
public function setHttpCode(){
|
||||||
|
http_response_code( $this->error == Err::Success ? 200 : 417 );
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
?>
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,428 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
namespace orm\core;
|
||||||
|
|
||||||
|
use \database\core\DatabaseDriver;
|
||||||
|
use \orm\core\Rows;
|
||||||
|
|
||||||
|
|
||||||
|
class SQLBuilder{
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "SELECT" AVEC UNE LISTE DE CHAMPS
|
||||||
|
*
|
||||||
|
* @sqlFields<Array> Liste de champs : [table => field => [func, alias] ]
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function SELECT($sqlFields){
|
||||||
|
return $sqlFields;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "ORDER BY" AVEC UNE LISTE DE CHAMPS
|
||||||
|
*
|
||||||
|
* @tables<Array> Liste de champs : [table => fields]
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function ORDERBY($tables){
|
||||||
|
return $tables;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "GROUP BY" AVEC UNE LISTE DE CHAMPS
|
||||||
|
*
|
||||||
|
* @tables<Array> Liste de champs : [table => fields]
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function GROUPBY($tables){
|
||||||
|
return $tables;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "FROM" AVEC UNE LISTE DE TABLES
|
||||||
|
*
|
||||||
|
* @tables<Array> Liste de tables OU SQL PUR
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function FROM($tables){
|
||||||
|
return $tables;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "UPDATE" AVEC LA TABLE EN QUESTION
|
||||||
|
*
|
||||||
|
* @table<String> Table en question
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function UPDATE($table){
|
||||||
|
return $table;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "DELETE" AVEC LA TABLE EN QUESTION
|
||||||
|
*
|
||||||
|
* @table<String> Table en question
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function DELETE($table){
|
||||||
|
return $table;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE TEXTUELLE "IN" AVEC UNE LISTE DE TABLES
|
||||||
|
*
|
||||||
|
* @field<Array> Tableau contenant [table, field]
|
||||||
|
* @array<Array> Valeurs de la clause IN
|
||||||
|
* @offset<int> Permet de rendre la condition unique (nommage des variables)
|
||||||
|
* @bound<Arary> Tableau associatif contenant les variables "bindés" -> ajout des champs
|
||||||
|
*
|
||||||
|
* @return sql<String> Renvoie le textuel formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function IN($field, $array, $offset=0, &$bound){
|
||||||
|
/* [0] Initialisation
|
||||||
|
=========================================================*/
|
||||||
|
$sql = '';
|
||||||
|
|
||||||
|
/* [1] On construit la requête
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Champ */
|
||||||
|
$sql .= $field[0].'.'.$field[1].' IN (';
|
||||||
|
|
||||||
|
/* (2) Valeurs */
|
||||||
|
$c = 0;
|
||||||
|
foreach($array as $i=>$value){
|
||||||
|
if( $c > 0 ) $sql .= ', ';
|
||||||
|
|
||||||
|
$sql .= ':'.$field[0].'_x_'.$field[1].'_'.$offset.'_'.$i;
|
||||||
|
|
||||||
|
$bound[':'.$field[0].'_x_'.$field[1].'_'.$offset.'_'.$i] = $value;
|
||||||
|
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return $sql.")";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE TEXTUELLE "WHERE" AVEC UNE LISTE DE TABLES
|
||||||
|
*
|
||||||
|
* @field<Array> Tableau contenant [table, field]
|
||||||
|
* @valeur<Array> Valeurs de la clause WHERE [valeur, opérateur]
|
||||||
|
* @offset<int> Permet de rendre la condition unique (nommage des variables)
|
||||||
|
* @bound<Arary> Tableau associatif contenant les variables "bindés" -> ajout des champs
|
||||||
|
*
|
||||||
|
* @return sql<String> Renvoie le textuel formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function WHERE($field, $value, $offset=0, &$bound){
|
||||||
|
/* [0] Initialisation
|
||||||
|
=========================================================*/
|
||||||
|
$sql = '';
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] On construit la requête
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Chamo */
|
||||||
|
$sql .= $field[0].'.'.$field[1].' ';
|
||||||
|
|
||||||
|
/* (2) Opérateur */
|
||||||
|
$sql .= substr($value[1], 2, -2).' ';
|
||||||
|
|
||||||
|
/* (3) Variable */
|
||||||
|
$sql .= ':'.$field[0].'_x_'.$field[1].'_'.$offset;
|
||||||
|
|
||||||
|
$bound[':'.$field[0].'_x_'.$field[1].'_'.$offset] = $value[0];
|
||||||
|
|
||||||
|
|
||||||
|
return $sql;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "SET" AVEC UNE LISTE DE TABLES
|
||||||
|
*
|
||||||
|
* @values<Array> Tableau de la forme [ field=>value, field2=>value2 ]
|
||||||
|
* @bound<Arary> Tableau associatif contenant les variables "bindés" -> ajout des champs
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un tableau formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function SET($values, &$bound){
|
||||||
|
/* [0] Initialisation
|
||||||
|
=========================================================*/
|
||||||
|
$sql = [];
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] On construit la requête
|
||||||
|
=========================================================*/
|
||||||
|
$c = 0;
|
||||||
|
foreach($values as $field=>$value){
|
||||||
|
/* (1) Champ */
|
||||||
|
$sql[$c] = $field.' = ';
|
||||||
|
|
||||||
|
/* (2) Variable */
|
||||||
|
$sql[$c] .= ':update_'.$field;
|
||||||
|
|
||||||
|
$bound[':update_'.$field] = $value;
|
||||||
|
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
return $sql;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE FORMATTEE "LIMIT" AVEC UN NOMBRE D'ENTREES
|
||||||
|
*
|
||||||
|
* @count<int> Nombre limite
|
||||||
|
*
|
||||||
|
* @return sql<Array> Renvoie un sql formatté
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function LIMIT($count=null){
|
||||||
|
/* [0] Initialisation
|
||||||
|
=========================================================*/
|
||||||
|
$sql = '';
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] On construit la requête
|
||||||
|
=========================================================*/
|
||||||
|
if( intval($count) == $count )
|
||||||
|
$sql = intval($count);
|
||||||
|
|
||||||
|
return $sql;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* CONSTRUIT LA REQUETE A PARTIR D'UNE REQUETTE FORMATTEE
|
||||||
|
*
|
||||||
|
* @request<Arary> Requête formattée
|
||||||
|
*
|
||||||
|
* @return sql<String> Requête formattée en SQL
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function BUILD($request){
|
||||||
|
/* [0] On initialise le retour
|
||||||
|
=========================================================*/
|
||||||
|
$sql = '';
|
||||||
|
|
||||||
|
/* [1] Gestion dans l'ordre
|
||||||
|
=========================================================*/
|
||||||
|
foreach($request as $clause=>$statements){
|
||||||
|
|
||||||
|
switch($clause){
|
||||||
|
|
||||||
|
/* (1) Clause SELECT
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'SELECT':
|
||||||
|
$sql .= "SELECT ";
|
||||||
|
$c = 0;
|
||||||
|
foreach($statements as $table=>$fields)
|
||||||
|
foreach($fields as $field=>$select){
|
||||||
|
|
||||||
|
/* (1) On construit le nom du champ */
|
||||||
|
$fieldStr = "$table.$field";
|
||||||
|
|
||||||
|
/* (2) On ajout le DISTINCT s'il y a lieu */
|
||||||
|
if( isset($select[1]) && $select[1] )
|
||||||
|
$fieldStr = "DISTINCT $fieldStr";
|
||||||
|
|
||||||
|
/* (3) On ajoute la fonction d'aggrégation s'il y a lieu */
|
||||||
|
if( isset($select[0]) && !is_null($select[0]) )
|
||||||
|
$fieldStr = substr($select[0], 2, -2)."($fieldStr)";
|
||||||
|
|
||||||
|
|
||||||
|
/* (4) On ajoute l'alias */
|
||||||
|
if( isset($select[0]) && !is_null($select[0]) )
|
||||||
|
$fieldStr = "$fieldStr as agg_$field";
|
||||||
|
else
|
||||||
|
$fieldStr = "$fieldStr";
|
||||||
|
|
||||||
|
$sql .= ($c==0) ? "$fieldStr" : ", $fieldStr";
|
||||||
|
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
$sql .= "\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
/* (2) Clause FROM
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'FROM':
|
||||||
|
$sql .= 'FROM ';
|
||||||
|
|
||||||
|
$c = 0;
|
||||||
|
foreach($statements as $field){
|
||||||
|
$sql .= ($c==0) ? "$field" : ", $field";
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
$sql .= "\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
|
||||||
|
/* (3) Clause WHERE
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'WHERE':
|
||||||
|
$c = 0;
|
||||||
|
foreach($statements as $field){
|
||||||
|
$sql .= ($c==0) ? "WHERE $field\n" : "AND $field\n";
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
$sql .= ($c==0) ? '' : "\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* (4) Clause LIMIT
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'LIMIT':
|
||||||
|
if( is_numeric($statements) )
|
||||||
|
$sql .= 'LIMIT '.intval($statements);
|
||||||
|
break;
|
||||||
|
|
||||||
|
|
||||||
|
/* (5) Clause DELETE
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'DELETE':
|
||||||
|
$sql .= "DELETE FROM $statements\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
|
||||||
|
/* (6) Clause UPDATE
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'UPDATE':
|
||||||
|
$sql .= "UPDATE $statements\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
|
||||||
|
/* (7) Clause SET
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'SET':
|
||||||
|
$c = 0;
|
||||||
|
foreach($statements as $field){
|
||||||
|
$sql .= ($c>0) ? "\n, $field" : "SET $field";
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
$sql .= "\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
/* (8) Clause GROUP BY
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'GROUPBY':
|
||||||
|
$sql .= 'GROUP BY ';
|
||||||
|
|
||||||
|
$c = 0;
|
||||||
|
foreach($statements as $table=>$fields)
|
||||||
|
foreach($fields as $field){
|
||||||
|
$sql .= ($c==0) ? "$table.$field" : ", $table.$field";
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
$sql .= "\n";
|
||||||
|
break;
|
||||||
|
|
||||||
|
/* (9) Clause ORDER BY
|
||||||
|
---------------------------------------------------------*/
|
||||||
|
case 'ORDERBY':
|
||||||
|
|
||||||
|
// si aucun ORDER BY, on quitte
|
||||||
|
if( count($statements) == 0 )
|
||||||
|
continue;
|
||||||
|
|
||||||
|
$sql .= 'ORDER BY ';
|
||||||
|
|
||||||
|
$c = 0;
|
||||||
|
foreach($statements as $table=>$fields)
|
||||||
|
foreach($fields as $field=>$order){
|
||||||
|
|
||||||
|
if( $c > 0 ) $sql .= ', ';
|
||||||
|
|
||||||
|
$sql .= "$table.$field ". substr($order, 2, -2);
|
||||||
|
|
||||||
|
$c++;
|
||||||
|
}
|
||||||
|
|
||||||
|
$sql .= "\n";
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] On retourne le résultat
|
||||||
|
=========================================================*/
|
||||||
|
return $sql;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
?>
|
||||||
|
|
@ -0,0 +1,194 @@
|
||||||
|
<?php
|
||||||
|
|
||||||
|
|
||||||
|
namespace orm\core;
|
||||||
|
|
||||||
|
use \database\core\DatabaseDriver;
|
||||||
|
use \orm\core\Rows;
|
||||||
|
|
||||||
|
|
||||||
|
// CLASSE MAITRE
|
||||||
|
class Table{
|
||||||
|
|
||||||
|
private static $database = 'logauth';
|
||||||
|
|
||||||
|
|
||||||
|
/* RENVOIE LES DONNEES D'UNE TABLE
|
||||||
|
*
|
||||||
|
* @table<String> Nom de la table à selectionner
|
||||||
|
*
|
||||||
|
* @return this<ORM> Retourne une instance de l'ORM
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
public static function get($table_name){
|
||||||
|
/* [0] Initialisation des attributs
|
||||||
|
=========================================================*/
|
||||||
|
$schema = [
|
||||||
|
'database' => self::$database,
|
||||||
|
'table' => null,
|
||||||
|
'columns' => null
|
||||||
|
];
|
||||||
|
|
||||||
|
|
||||||
|
/* [1] On vérifie que la table existe
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) Requête */
|
||||||
|
$checkTable = Database::getPDO()->query("SHOW tables FROM ".self::$database);
|
||||||
|
$checkTableResult = Database::delNumeric( $checkTable->fetchAll() );
|
||||||
|
|
||||||
|
/* (2) On met en forme les données */
|
||||||
|
$tables = [];
|
||||||
|
foreach($checkTableResult as $table)
|
||||||
|
$tables[] = $table['Tables_in_'.self::$database];
|
||||||
|
|
||||||
|
/* (3) Si n'existe pas, on renvoie une erreur */
|
||||||
|
if( !in_array($table_name, $tables) )
|
||||||
|
return null;
|
||||||
|
|
||||||
|
/* (4) On enregistre les données */
|
||||||
|
$schema['table'] = $table_name;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [2] Si la table existe, on récupère les colonnes
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On récupère les colonnes */
|
||||||
|
$getColumns = Database::getPDO()->query("SHOW columns FROM ".self::$database.'.'.$table_name);
|
||||||
|
$columnsResult = Database::delNumeric( $getColumns->fetchAll() );
|
||||||
|
|
||||||
|
/* (2) On met en forme les données */
|
||||||
|
$columns = [];
|
||||||
|
foreach($columnsResult as $col){
|
||||||
|
// On formatte le type //
|
||||||
|
$type = $col['Type'];
|
||||||
|
if( preg_match('/^(int|float|varchar|text)/i', $type, $m) )
|
||||||
|
$type = strtolower($m[1]);
|
||||||
|
|
||||||
|
// On ajoute la colonne //
|
||||||
|
$columns[$col['Field']] = [
|
||||||
|
'type' => $type,
|
||||||
|
'primary' => $col['Key'] == 'PRI'
|
||||||
|
];
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* (3) Si on trouve rien, on envoie une erreur */
|
||||||
|
if( !is_array($columns) || count($columns) == 0 )
|
||||||
|
return null;
|
||||||
|
|
||||||
|
/* (4) On enregistre les colonnes */
|
||||||
|
$schema['columns'] = $columns;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] On récupère les clés étrangères
|
||||||
|
=========================================================*/
|
||||||
|
/* (1) On récupère le texte du 'CREATE TABLE' */
|
||||||
|
$getCreateTable = Database::getPDO()->query("show create table ".$table_name);
|
||||||
|
$create_table = $getCreateTable->fetch()['Create Table'];
|
||||||
|
|
||||||
|
/* (2) On découpte en lignes */
|
||||||
|
$create_table_lines = explode("\n", $create_table);
|
||||||
|
|
||||||
|
/* (3) Pour chaque ligne, si c'est une contrainte, on l'enregistre dans la colonne associée */
|
||||||
|
foreach($create_table_lines as $i=>$line)
|
||||||
|
if( preg_match('/CONSTRAINT `.+` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)+/i', $line, $m) )
|
||||||
|
$schema['columns'][$m[1]]['references'] = [$m[2], $m[3]];
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/* [3] On renvoie une instance de 'Rows'
|
||||||
|
=========================================================*/
|
||||||
|
return new Rows($schema);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/*** USE CASE :: ACCESS TABLE `user` ***/
|
||||||
|
// ORM::Table('user');
|
||||||
|
|
||||||
|
|
||||||
|
/**** USE CASE :: WHERE ****/
|
||||||
|
// WHERE `username` = 'someUsername'
|
||||||
|
// ORM::Table('user')->whereUsername('someUsername');
|
||||||
|
// EQUIVALENT TO
|
||||||
|
// ORM::Table('user')->whereUsername('someUsername', Rows::COND_EQUAL);
|
||||||
|
|
||||||
|
// WHERE `id_user` < 100
|
||||||
|
// ORM::Table('user')->whereIdUser(100, Rows::COND_INF);
|
||||||
|
|
||||||
|
// WHERE `id_user` <= 100
|
||||||
|
// ORM::Table('user')->whereIdUser(100, Rows::COND_INFEQ);
|
||||||
|
|
||||||
|
// WHERE `id_user` > 10
|
||||||
|
// ORM::Table('user')->whereIdUser(10, Rows::COND_SUP);
|
||||||
|
|
||||||
|
// WHERE `id_user` >= 10
|
||||||
|
// ORM::Table('user')->whereIdUser(10, Rows::COND_SUPEQ);
|
||||||
|
|
||||||
|
// WHERE `id_user` in (1, 2, 3, 8)
|
||||||
|
// ORM::Table('user')->whereIdUser([1, 2, 3, 8], Rows::COND_IN);
|
||||||
|
|
||||||
|
// WHERE `id_user` LIKE 'John %'
|
||||||
|
// ORM::Table('user')->whereIdUser('John %', Rows::COND_LIKE);
|
||||||
|
|
||||||
|
|
||||||
|
/*** USE CASE :: ORDER BY ****/
|
||||||
|
// ORDER BY `a` ASC, `b` DESC
|
||||||
|
// Table::get('someTable')
|
||||||
|
// ->orderby('a', Rows::ORDER_ASC)
|
||||||
|
// ->orderby('b', Rows::ORDER_DESC);
|
||||||
|
//
|
||||||
|
// Note: `Rows::ORDER_ASC` is set by default if the given FLAG is invalid
|
||||||
|
|
||||||
|
|
||||||
|
/**** USE CASE :: SELECT ****/
|
||||||
|
// SELECT id_user, username
|
||||||
|
// Table::get('user')
|
||||||
|
// ->select('id_user')
|
||||||
|
// ->select('username');
|
||||||
|
|
||||||
|
|
||||||
|
/**** USE CASE :: AGGREGATION FUNCTIONS ****/
|
||||||
|
// SELECT COUNT(`count`)
|
||||||
|
// Table::get('user')->select('count', Rows::SEL_COUNT)
|
||||||
|
|
||||||
|
// SELECT SUM(distinct `count`)
|
||||||
|
// Table::get('user')->select('count', Rows::SEL_SUM, Rows::SEL_DISTINCT);
|
||||||
|
|
||||||
|
// SELECT AVG(`count`)
|
||||||
|
// Table::get('user')->select('count', Rows::SEL_AVG);
|
||||||
|
|
||||||
|
// SELECT MAX(`id_user`)
|
||||||
|
// Table::get('user')->select('id_user', Rows::SEL_MAX);
|
||||||
|
|
||||||
|
// SELECT MIN(`id_user`)
|
||||||
|
// Table::get('user')->select('id_user', Rows::SEL_MIN);
|
||||||
|
|
||||||
|
// SELECT GROUP_CONCAT(`count`)
|
||||||
|
// Table::get('user')->select('count', Rows::SEL_CONCAT);
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/**** USE CASE :: FETCH ****/
|
||||||
|
// SELECT ... FROM ... WHERE ... ORDERBY ... LIMIT ...
|
||||||
|
// Table::get('user')
|
||||||
|
// ->select('id_user')
|
||||||
|
// ->fetch();
|
||||||
|
|
||||||
|
// SELECT UNIQUE ... FROM ... WHERE ... ORDERBY ... LIMIT ...
|
||||||
|
// Table::get('user')
|
||||||
|
// ->select('id_user')
|
||||||
|
// ->unique->fetch();
|
||||||
|
|
||||||
|
|
||||||
|
/**** USE CASE :: TABLE JOIN ****/
|
||||||
|
// WHERE `user`.`id_user` = `user_merge`.`id_user`
|
||||||
|
// Table::get('user_merge')->join(
|
||||||
|
// Table::get('user')->whereIdUser(1, Rows::COND_SUP)
|
||||||
|
// );
|
||||||
Loading…
Reference in New Issue