Ajout du nouveau système de console
This commit is contained in:
OsaAjani
parent
063f0c97a3
commit
bdd7b3dccc
41
console.php
41
console.php
|
|
@ -7,20 +7,21 @@
|
|||
##############
|
||||
# INCLUSIONS #
|
||||
##############
|
||||
//On va inclure l'ensemble des fichiers necessaires
|
||||
require_once('./mvc/constants.php');
|
||||
require_once('./mvc/autoload.php');
|
||||
require_once('./mvc/conn_bdd.php');
|
||||
require_once('./mvc/secho.php');
|
||||
require_once('./mvc/Controller.php');
|
||||
require_once('./mvc/Router.php');
|
||||
require_once('./mvc/Model.php');
|
||||
require_once(__DIR__ . '/mvc/constants.php');
|
||||
require_once(PWD . 'mvc/autoload.php');
|
||||
require_once(PWD . 'mvc/conn_bdd.php');
|
||||
require_once(PWD . 'mvc/secho.php');
|
||||
require_once(PWD . 'mvc/Controller.php');
|
||||
require_once(PWD . 'mvc/ApiController.php');
|
||||
require_once(PWD . 'mvc/Router.php');
|
||||
require_once(PWD . 'mvc/Model.php');
|
||||
require_once(PWD . 'mvc/Console.php');
|
||||
|
||||
#########
|
||||
# MODEL #
|
||||
#########
|
||||
//On va appeler un modèle, est l'initialiser
|
||||
$db = new DataBase($bdd);;
|
||||
$db = new DataBase($bdd);
|
||||
|
||||
//On va ajouter les réglages globaux de RaspiSMS modifiables via l'interface
|
||||
$settings = $db->getFromTableWhere('settings');
|
||||
|
|
@ -33,23 +34,5 @@
|
|||
# ROUTAGE #
|
||||
###########
|
||||
//Partie gérant l'appel des controlleurs
|
||||
$controller = new internalConsole();
|
||||
|
||||
$options = getopt('c:');
|
||||
|
||||
if (!isset($options['c'])) //Si on a pas reçu de methode à appeler
|
||||
{
|
||||
echo "Vous devez précisez un script à appeler (-c 'nom du script').\n";
|
||||
echo "Pour plus d'infos, utilisez -c 'help'\n";
|
||||
exit(1); //Sorti avec erreur
|
||||
}
|
||||
|
||||
if (!method_exists($controller, $options['c'])) //Si la méthode reçue est incorrect
|
||||
{
|
||||
echo "Vous avez appelé un script incorrect.\n";
|
||||
echo "Pour plus d'infos, utilisez -c 'help'\n";
|
||||
exit(2); //Sorti avec erreur
|
||||
}
|
||||
|
||||
$controller->$options['c'](); //On appel la fonction
|
||||
|
||||
$console = new Console($argv);
|
||||
$console->executeCommand($console->getCommand());
|
||||
|
|
|
|||
|
|
@ -1,73 +1,6 @@
|
|||
<?php
|
||||
class internalConsole extends Controller
|
||||
{
|
||||
|
||||
/**
|
||||
* Cette fonction retourne l'aide de la console
|
||||
*/
|
||||
public function help()
|
||||
{
|
||||
//On définit les commandes disponibles
|
||||
$commands = array(
|
||||
'sendScheduleds' => array(
|
||||
'description' => 'Cette commande permet d\'envoyer les SMS programmés qui doivent l\'êtres.',
|
||||
'requireds' => array(),
|
||||
'optionals' => array(),
|
||||
),
|
||||
'parseReceivedSMS' => array(
|
||||
'description' => 'Cette commande permet d\'enregistrer un SMS, et de l\'analyser pour voir s\'il contient une commande. Pour cela, il analyse le dossier PWD_RECEIVEDS',
|
||||
'requireds' => array(
|
||||
),
|
||||
'optionals' => array(),
|
||||
),
|
||||
'sendTransfers' => array(
|
||||
'description' => 'Cette commande permet d\'envoyer par mails les sms à transférés.',
|
||||
'requireds' => [],
|
||||
'optionals' => [],
|
||||
),
|
||||
);
|
||||
|
||||
$message = "Vous êtes ici dans l'aide de la console.\n";
|
||||
$message .= "Voici la liste des commandes disponibles : \n";
|
||||
|
||||
//On écrit les texte pour la liste des commandes dispos
|
||||
foreach ($commands as $name => $value)
|
||||
{
|
||||
$requireds = isset($value['requireds']) ? $value['requireds'] : array();
|
||||
$optionals = isset($value['optionals']) ? $value['optionals'] : array();
|
||||
|
||||
$message .= ' ' . $name . ' : ' . $value['description'] . "\n";
|
||||
$message .= " Arguments obligatoires : \n";
|
||||
if (!count($requireds))
|
||||
{
|
||||
$message .= " Pas d'argument\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach ($requireds as $argument => $desc)
|
||||
{
|
||||
$message .= ' - ' . $argument . ' : ' . $desc . "\n";
|
||||
}
|
||||
}
|
||||
|
||||
$message .= " Arguments optionnels : \n";
|
||||
|
||||
if (!count($optionals))
|
||||
{
|
||||
$message .= " Pas d'argument\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach ($optionals as $argument => $desc)
|
||||
{
|
||||
$message .= ' - ' . $argument . ' : ' . $desc . "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
echo $message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette fonction envoie tous les SMS programmés qui doivent l'être
|
||||
*/
|
||||
|
|
@ -472,6 +405,8 @@
|
|||
echo "Query do to " . $webhookQuerie['url'] . " with datas " . $datas . "\n";
|
||||
}
|
||||
|
||||
$db->deleteWebhookQueriesIn($webhookQueriesIds);
|
||||
|
||||
//On attend 2 secondes
|
||||
sleep(2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,6 +51,9 @@
|
|||
case 'COMMAND_ADD' :
|
||||
$logo = 'fa-terminal';
|
||||
break;
|
||||
case 'WEBHOOK_ADD' :
|
||||
$logo = 'fa-plug';
|
||||
break;
|
||||
default :
|
||||
$logo = 'fa-question';
|
||||
}
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@
|
|||
return false;
|
||||
}
|
||||
|
||||
$db->insertIntoTable('events', ['type' => 'WEBHOOKS_ADD', 'text' => 'Ajout webhook : ' . $type . ' => ' . $url]);
|
||||
$db->insertIntoTable('events', ['type' => 'WEBHOOK_ADD', 'text' => 'Ajout webhook : ' . array_search($type, internalConstants::WEBHOOK_TYPE) . ' (' . $url . ')']);
|
||||
|
||||
$_SESSION['successmessage'] = 'Le webhook a bien été créé.';
|
||||
header('Location: ' . $this->generateUrl('webhooks'));
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@
|
|||
require_once('./mvc/conn_bdd.php');
|
||||
require_once('./mvc/secho.php');
|
||||
require_once('./mvc/Controller.php');
|
||||
require_once('./mvc/ApiController.php');
|
||||
require_once('./mvc/Router.php');
|
||||
require_once('./mvc/Model.php');
|
||||
|
||||
|
|
|
|||
|
|
@ -602,6 +602,26 @@
|
|||
return $this->runQuery($query, $params);
|
||||
}
|
||||
|
||||
/**
|
||||
* Supprime tous les webhooks dont l'id fait partie du tableau fourni
|
||||
* @param $webhooks_ids : Tableau des id des webhooks à supprimer
|
||||
* @return int : Nombre de lignes supprimées
|
||||
*/
|
||||
public function deleteWebhooksIn($webhooks_ids)
|
||||
{
|
||||
$query = "
|
||||
DELETE FROM webhooks
|
||||
WHERE id ";
|
||||
|
||||
//On génère la clause IN et les paramètres adaptés depuis le tableau des id
|
||||
$generted_in = $this->generateInFromArray($webhooks_ids);
|
||||
$query .= $generted_in['QUERY'];
|
||||
$params = $generted_in['PARAMS'];
|
||||
|
||||
return $this->runQuery($query, $params, self::ROWCOUNT);
|
||||
}
|
||||
|
||||
|
||||
/***************************************/
|
||||
/* PARTIE DES REQUETES WEBHOOK_QUERIES */
|
||||
/***************************************/
|
||||
|
|
@ -628,18 +648,18 @@
|
|||
}
|
||||
|
||||
/**
|
||||
* Supprime tous les webhooks dont l'id fait partie du tableau fourni
|
||||
* @param $webhooks_ids : Tableau des id des webhooks à supprimer
|
||||
* Supprime tous les webhook_queries dont l'id fait partie du tableau fourni
|
||||
* @param $webhook_queries_ids : Tableau des id des webhook_queries à supprimer
|
||||
* @return int : Nombre de lignes supprimées
|
||||
*/
|
||||
public function deleteWebhooksIn($webhooks_ids)
|
||||
public function deleteWebhookQueriesIn($webhook_queries_ids)
|
||||
{
|
||||
$query = "
|
||||
DELETE FROM webhooks
|
||||
DELETE FROM webhook_queries
|
||||
WHERE id ";
|
||||
|
||||
//On génère la clause IN et les paramètres adaptés depuis le tableau des id
|
||||
$generted_in = $this->generateInFromArray($webhooks_ids);
|
||||
$generted_in = $this->generateInFromArray($webhook_queries_ids);
|
||||
$query .= $generted_in['QUERY'];
|
||||
$params = $generted_in['PARAMS'];
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,128 @@
|
|||
<?php
|
||||
/**
|
||||
* Cette classe sert de mère à tous les controlleurs destiné à la création d'API. Elle hérite de toutes les infos d'un controller standard, mais elle embarque en plus des mécanismes propres aux api REST, etc.
|
||||
*/
|
||||
class ApiController extends Controller
|
||||
{
|
||||
protected $method;
|
||||
|
||||
/**
|
||||
* Cette fonction construit la classe, elle prend en paramètre obligatoire le type de méthode (PUT, GET, POST, etc) avec laquel on a appelée la page
|
||||
*/
|
||||
public function __construct ()
|
||||
{
|
||||
//On va choisir le type à employer
|
||||
$method = $_SERVER['REQUEST_METHOD'];
|
||||
switch (mb_convert_case($method, MB_CASE_LOWER))
|
||||
{
|
||||
case 'delete' :
|
||||
$this->method = 'DELETE';
|
||||
break;
|
||||
case 'patch' :
|
||||
$this->method = 'PATCH';
|
||||
break;
|
||||
case 'post' :
|
||||
$this->method = 'POST';
|
||||
break;
|
||||
case 'put' :
|
||||
$this->method = 'PUT';
|
||||
break;
|
||||
default :
|
||||
$this->method = 'GET';
|
||||
}
|
||||
|
||||
//On construit aussi le controller traditionnel
|
||||
parent::__construct();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette fonction permet d'effectuer n'importe quelle opération sur le header en retournant le controller en cours
|
||||
* @param string $key : La clef du header
|
||||
* @param string $value : La valeur à donner
|
||||
* @return ApiController : On retourne l'API controlleur lui meme pour pouvoir chainer
|
||||
*/
|
||||
public function setHeader ($key, $value)
|
||||
{
|
||||
header($key . ': ' . $value);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette fonction permet de définir un code de retour HTTP
|
||||
* @param int $code : Le numéro du code de retour HTTP
|
||||
* @return ApiController : On retourne l'API controlleur lui meme pour pouvoir chainer
|
||||
*/
|
||||
public function setHttpCode ($code)
|
||||
{
|
||||
http_response_code($code);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette fonction permet de définir un code de retour automatiquement selon le contexte du controller (c'est à dire si on l'appel en POST, en GET, etc.)
|
||||
* @param boolean $success : Si la requete est un succes ou non (par défaut à true)
|
||||
* @return ApiController : On retourne l'API controlleur lui meme pour pouvoir chainer
|
||||
*/
|
||||
public function autoHttpCode ($success = true)
|
||||
{
|
||||
$responseCodes = array(
|
||||
'GET' => array(
|
||||
'success' => 200,
|
||||
'fail' => 404,
|
||||
),
|
||||
'DELETE' => array(
|
||||
'success' => 204,
|
||||
'fail' => 400,
|
||||
),
|
||||
'PATCH' => array(
|
||||
'success' => 204,
|
||||
'fail' => 400,
|
||||
),
|
||||
'POST' => array(
|
||||
'success' => 201,
|
||||
'fail' => 400,
|
||||
),
|
||||
'PUT' => array(
|
||||
'success' => 204,
|
||||
'fail' => 400,
|
||||
),
|
||||
);
|
||||
|
||||
$key = $success ? 'success' : 'fail';
|
||||
|
||||
return $this->setHttpCode($responseCodes[$this->method][$key]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette fonction permet de faire un retour sous forme de json
|
||||
* @param array $datas : Les données à retourner sous forme de json
|
||||
* @param boolean $secure : Défini si l'affichage doit être sécurisé contre les XSS, par défaut true
|
||||
* @return ApiController : On retourne l'API controlleur lui meme pour pouvoir chainer
|
||||
*/
|
||||
public function json ($datas, $secure = true)
|
||||
{
|
||||
header('Content-Type: application/json');
|
||||
|
||||
if ($secure)
|
||||
{
|
||||
echo htmlspecialchars(json_encode($datas), ENT_NOQUOTES);
|
||||
}
|
||||
else
|
||||
{
|
||||
echo json_encode($datas);
|
||||
}
|
||||
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette fonction permet de fixer la location renvoyée en HTTP
|
||||
* @param string $location : La location à renvoyer
|
||||
* @return ApiController : On retourne l'API controlleur lui meme pour pouvoir chainer
|
||||
*/
|
||||
public function setLocation ($location)
|
||||
{
|
||||
header('Location: ' . $location);
|
||||
return $this;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,307 @@
|
|||
<?php
|
||||
/**
|
||||
* Cette classe gère l'appel d'une console
|
||||
*/
|
||||
class Console
|
||||
{
|
||||
public $command; //Commande invoquée complète (sous forme de tableau)
|
||||
|
||||
/**
|
||||
* Constructeur de la classe console
|
||||
* @param mixed $command : Tableau de la commande appelée (voir $argv). Si non fourni la console est construite vide.
|
||||
*/
|
||||
public function __construct($command = false)
|
||||
{
|
||||
if ($command)
|
||||
{
|
||||
$this->command = $command;
|
||||
}
|
||||
else
|
||||
{
|
||||
$this->command = [];
|
||||
}
|
||||
}
|
||||
|
||||
//Getters et setters
|
||||
public function getCommand()
|
||||
{
|
||||
return $this->command;
|
||||
}
|
||||
|
||||
public function setCommand($value)
|
||||
{
|
||||
$this->command = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette méthode vérifie si une commande demande explicitement d'appeler l'aide
|
||||
* @param array $command : La commande appelée
|
||||
* @param boolean : Vrai si on doit appeler l'aide, faux sinon
|
||||
*/
|
||||
public function parseForHelp ($command)
|
||||
{
|
||||
return (isset($command[1]) && $command[1] == '--help');
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne le controlleur à appeler d'après une commande
|
||||
* @param array $command : La commande à analyser
|
||||
* @return mixed : Le nom du controlleur à appeler si la commande en contient un, et faux sinon ou si le controlleur n'existe pas
|
||||
*/
|
||||
public function parseForController($command)
|
||||
{
|
||||
//Si on doit chercher de l'aide globale, on retire la demande d'aide
|
||||
if ($this->parseForHelp($command))
|
||||
{
|
||||
unset($command[1]);
|
||||
$command = array_values($command);
|
||||
}
|
||||
|
||||
//Pas de controlleur à appeler
|
||||
if (!isset($command[1]))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
$controllerName = $command[1];
|
||||
|
||||
if (!file_exists(PWD_CONTROLLER . $controllerName . '.php'))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return $controllerName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la méthode à appeler d'après une commande
|
||||
* @param array $command : La commande à analyser
|
||||
* @return mixed : Le nom de la méthode à appeler si la commande en contient une, et faux sinon ou si la méthode n'existe pas pour le controlleur demandé
|
||||
*/
|
||||
public function parseForMethod($command)
|
||||
{
|
||||
//Si on doit chercher de l'aide globale, on retire la demande d'aide
|
||||
if ($this->parseForHelp($command))
|
||||
{
|
||||
unset($command[1]);
|
||||
$command = array_values($command);
|
||||
}
|
||||
|
||||
//Le controlleur n'existe pas
|
||||
if (!$controllerName = $this->parseForController($command))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//Si on a pas fourni de méthode
|
||||
if (!isset($command[2]))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
$methodName = $command[2];
|
||||
|
||||
//La méthode n'existe pas
|
||||
if (!method_exists($controllerName, $methodName))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return $methodName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne les paramètres d'une méthode d'après une commande
|
||||
* @param array $command : La commande à analyser
|
||||
* @return mixed : Le tableau des paramètres fournis (au format 'name' => 'value') ou faux si la méthode ou le controlleur n'existe pas
|
||||
*/
|
||||
public function parseForParams($command)
|
||||
{
|
||||
//Si on doit chercher de l'aide globale, on retire la demande d'aide
|
||||
if ($this->parseForHelp($command))
|
||||
{
|
||||
unset($command[1]);
|
||||
$command = array_values($command);
|
||||
}
|
||||
|
||||
//Le controlleur n'existe pas
|
||||
if (!$controllerName = $this->parseForController($command))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//La méthode n'existe pas
|
||||
if (!$methodName = $this->parseForMethod($command))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//On construit la liste des arguments passés à la commande au format 'name' => 'value'
|
||||
unset($command[0], $command[1], $command[2]);
|
||||
$command = array_values($command);
|
||||
$params = [];
|
||||
|
||||
foreach ($command as $param)
|
||||
{
|
||||
$param = explode('=', $param, 2);
|
||||
$paramName = str_replace('--', '', $param[0]);
|
||||
$paramValue = $param[1];
|
||||
$params[$paramName] = $paramValue;
|
||||
}
|
||||
|
||||
return $params;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si une commande contient tous les paramètres obligatoires d'une méthode et retourne un tableau des arguments remplis
|
||||
* @param array $command : La commande à analyser
|
||||
* @return mixed : Si tout est bon, un tableau un contenant les différents paramètres dans l'ordre où ils doivent êtres passé à la méthode. Sinon, si par exemple un paramètre obligatoire est manquant false.
|
||||
*/
|
||||
public function checkParametersValidityForCommand($command)
|
||||
{
|
||||
//Le controlleur n'existe pas
|
||||
if (!$controllerName = $this->parseForController($command))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//La méthode n'existe pas
|
||||
if (!$methodName = $this->parseForMethod($command))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//Les paramètres retournes une erreur
|
||||
$commandParams = $this->parseForParams($command);
|
||||
if ($commandParams === false)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//On construit la liste des arguments de la méthode, dans l'ordre
|
||||
$reflection = new ReflectionMethod($controllerName, $methodName);
|
||||
$methodArguments = [];
|
||||
|
||||
foreach ($reflection->getParameters() as $parameter)
|
||||
{
|
||||
//Si le paramètre n'est pas fourni et n'as pas de valeur par défaut
|
||||
if (!array_key_exists($parameter->getName(), $commandParams) && !$parameter->isDefaultValueAvailable())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//Si on a une valeur par défaut dispo, on initialise la variable avec
|
||||
if ($parameter->isDefaultValueAvailable())
|
||||
{
|
||||
$methodArguments[$parameter->getName()] = $parameter->getDefaultValue();
|
||||
}
|
||||
|
||||
//Si la variable n'existe pas, on passe
|
||||
if (!array_key_exists($parameter->getName(), $commandParams))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
//On ajoute la variable dans le tableau des arguments de la méthode
|
||||
$methodArguments[$parameter->getName()] = $commandParams[$parameter->getName()];
|
||||
}
|
||||
|
||||
return $methodArguments;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette méthode retourne le texte d'aide d'un controller ou d'une de ses méthodes
|
||||
* @param array $command : La commande appelée
|
||||
* @param string $controller : Le nom du controller pour lequel on veux l'aide, ou false (par défaut)
|
||||
* @param string $method : La nom de la méthode pour laquelle on veux de l'aide, ou false (par défaut)
|
||||
* @param boolean $missingArguments : Si il manque des arguments obligatoires pour la méthode (par défaut faux)
|
||||
* @param string : Le texte d'aide à afficher
|
||||
*/
|
||||
public function getHelp ($command, $controller = false, $method = false, $missingArguments = false)
|
||||
{
|
||||
$retour = '';
|
||||
|
||||
$retour .= "Aide : \n";
|
||||
|
||||
//Si pas de controlleur, on sort l'aide par défaut
|
||||
if (!$controller)
|
||||
{
|
||||
$retour .= "Vous n'avez pas fournit de controller à appeler. Pour voir l'aide : " . $command[0] . " --help <nom controller> <nom methode>\n";
|
||||
return $retour;
|
||||
}
|
||||
|
||||
if ($missingArguments)
|
||||
{
|
||||
$retour .= "Vous n'avez pas fournis tous les arguments obligatoire pour cette fonction. Pour rappel : \n";
|
||||
}
|
||||
|
||||
//Si on a pas définie la méthode, on les fait toutes, sinon juste celle définie
|
||||
if (!$method)
|
||||
{
|
||||
$retour .= 'Aide du controller ' . $controller . "\nMéthodes : \n";
|
||||
$reflection = new ReflectionClass($controller);
|
||||
$reflectionMethods = $reflection->getMethods();
|
||||
}
|
||||
else
|
||||
{
|
||||
$reflectionMethods = [new ReflectionMethod($controller, $method)];
|
||||
$retour .= 'Aide du controller ' . $controller . ' et de la méthode ' . $method . "\n";
|
||||
}
|
||||
|
||||
//Pour chaque méthode, on affiche l'aide
|
||||
foreach ($reflectionMethods as $reflectionMethod)
|
||||
{
|
||||
$retour .= " " . $reflectionMethod->getName();
|
||||
|
||||
//On ajoute chaque paramètre au retour
|
||||
foreach ($reflectionMethod->getParameters() as $parameter)
|
||||
{
|
||||
$retour .= ' --' . $parameter->getName() . "=<value" . ($parameter->isDefaultValueAvailable() ? ' (par défaut, ' . gettype($parameter->getDefaultValue()) . ':' . str_replace(PHP_EOL, '', print_r($parameter->getDefaultValue(), true)) . ')': '') . ">";
|
||||
}
|
||||
|
||||
$retour .= "\n";
|
||||
}
|
||||
|
||||
return $retour;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cette méthode tente d'appeler le controlleur et la méthode correspondant à la commande, avec les arguments demandés
|
||||
* @param array $command : La commande appelée
|
||||
*/
|
||||
public function executeCommand ($command)
|
||||
{
|
||||
//Si on a pas de controller à appeler
|
||||
if (!$controller = $this->parseForController($command))
|
||||
{
|
||||
echo $this->getHelp($command);
|
||||
return false;
|
||||
}
|
||||
|
||||
//Si on a pas de méthode à appeler
|
||||
if (!$method = $this->parseForMethod($command))
|
||||
{
|
||||
echo $this->getHelp($command, $controller);
|
||||
return false;
|
||||
}
|
||||
|
||||
//Si on a pas tous les arguments necessaires à la méthode
|
||||
$params = $this->checkParametersValidityForCommand($command);
|
||||
if ($params === false)
|
||||
{
|
||||
echo $this->getHelp($command, $controller, $method, true);
|
||||
return false;
|
||||
}
|
||||
|
||||
//Si on doit appeler l'aide
|
||||
if ($this->parseForHelp($command))
|
||||
{
|
||||
echo $this->getHelp($command, $controller, $method);
|
||||
return false;
|
||||
}
|
||||
|
||||
//Si tout est bien ok, on appel la méthode
|
||||
return call_user_func_array([$controller, $method], $params);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -637,7 +637,7 @@
|
|||
}
|
||||
|
||||
//On fabrique la requete
|
||||
$query = "INSERT INTO " . $table . "(" . implode(', ', $fieldNames) . ") VALUES(:" . implode(', :', $fieldNames) . ")";
|
||||
$query = "INSERT INTO " . $table . " (" . implode(', ', $fieldNames) . ") VALUES(:" . implode(', :', $fieldNames) . ")";
|
||||
|
||||
//On retourne le nombre de lignes insérées
|
||||
return $this->runQuery($query, $params, self::ROWCOUNT);
|
||||
|
|
|
|||
Loading…
Reference in New Issue