wellton/wMind
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade
Arquivos
54f9c60f6aa04b29097a814ab84482886b9a0d7d
wMind/mind3rd/API/classes/MindCommand.php
T

560 linhas
16 KiB
PHP
Arquivo Executável
Original Anotar Histórico

<?php
/**
* This file is part of TheWebMind 3rd generation.
*
* @author Felipe Nascimento de Moura <felipenmoura@gmail.com>
* @license licenses/mind3rd.license
*/
use Symfony\Component\Console\Input\InputArgument,
Symfony\Component\Console\Input\InputOption,
Symfony\Component\Console;
/**
* This class extends the class Command, from Symfony.
* All programs should extend it
*
* @author felipe Nascimento de Moura <felipenmoura@gmail.com>
*/
class MindCommand extends Symfony\Component\Console\Command\Command
{
private $restrict = true;
private $fileName = null;
private $requiredArguments = Array();
private $optionalArguments = Array();
private $requiredOptions = Array();
private $optionalOptions = Array();
private $commandFlags = Array();
private $adminOnly = false;
public $answers = Array();
public $commandAction = null;
public $commandAvailableOptions = Array();
/**
* A required call, to set your program to work.
* This method initiates the program registering it to the application's core.
*/
public function init()
{
parent::__construct();
}
/**
* This method configures your program to the application.
* You don't need to call it.
*/
final public function configure()
{
$this->setDefinition(Array());
$this->setName($this->commandName);
$definition= Array();
$definition= array_merge($this->requiredArguments,
$this->requiredOptions,
$this->optionalArguments,
$this->optionalOptions,
$this->commandFlags);
$helpDetails= "\n";
$avOptsStr= Array();
foreach($this->commandAvailableOptions as $k=>$avOpts)
{
if($avOpts)
{
$avOptsStr[]= " ->".$k."\n ".implode(', ', $avOpts);
}
}
if(sizeof($avOptsStr)>0)
$helpDetails.= "\nAvailables options:\n".implode("\n", $avOptsStr);
$this->setHelp($this->getHelp().$helpDetails);
$this->setDefinition($definition);
}
/**
* This is a quite useful method for you to deal with user interaction.
*
* You can use this method to get information already sent by the user trhough POST
* or asking the user via console.
* It deals with the environment and sets the answered values to the $this->answers properties.
*
* Example: $myCommand->prompt('name', 'what is your name?');
* echo $myCommand->answers['name'];
*
* @param string $name
* @param string $question
* @param boolean $mode Set it to true, if it is a password(then, it will be represented by * in the console
* @return mixed the answer
*/
public function prompt($name, $question, $mode=false)
{
GLOBAL $_REQ;
$secret= false;
$options= false;
if($mode)
{
if(is_array($mode))
{
$options= $mode;
}else
$secret= true;
}
$answer= null;
if($_REQ['env'] !='http')
{
do
{
echo $question."\n";
if($options)
{
echo "(";
$optionLegend= Array();
foreach($options as $optVal=>$optLabel)
{
$optionLegend[]= $optVal."=".$optLabel;
}
echo trim(implode(" |", $optionLegend));
echo ")\n";
}
if(!$secret)
{
$fp = fopen('php://stdin', 'r');
$answer = trim(fgets($fp, 1024));
if($options &&
!in_array(strtolower($answer),
array_map('strtolower', array_keys($options))))
{
Mind::write('invalidOptionValue', true, $answer, $name);
$answer= false;
}
}else{
$answer= $this->readPassword('*');
}
}while(!$answer);
}else{
if(isset($_POST[$name]))
{
$answer= $_POST[$name];
if($options &&
!in_array(strtolower($answer),
array_map('strtolower', $options)))
{
Mind::write('invalidOptionValue', true, $answer, $name);
$answer= false;
}
}
if(!$answer)
{
Mind::write('missingParameter', true, $name);
exit;
}
}
$this->answers[$name]= trim($answer);
return $this->answers[$name];
}
/**
* Adds a required argument to your command.
*
* That means that, the given parameter MUST be passed to the command to execute.
* Example: auth felipenmoura
* in this case, 'auth' is the command and 'felipenmoura' is the required argument
*
* @param string $argName
* @param string $description
* @param Array $availableOptions A list of available options
* @return MindCommand
*/
public function addRequiredArgument($argName,
$description='',
$availableOptions=null)
{
if($availableOptions)
$description.= "(".implode(', ', $availableOptions).")";
$this->requiredArguments[$argName]= new InputArgument($argName,
InputArgument::REQUIRED,
$description);
$this->commandAvailableOptions[$argName]= $availableOptions;
return $this;
}
/**
* Adds an optional argument to the command.
* An optional argument is that argument which may be ommited when the command is called.
* Example: auth admin 1234
* Where 'auth' is the command, 'admin' is the required argument and '1234' is the password, an optional argument.
*
* @param string $argName
* @param string $description
* @param Array $availableOptions A list of available options to the argument
* @return MindCommand
*/
public function addOptionalArgument($argName,
$description='',
$availableOptions=null)
{
if($availableOptions)
$description.= "(".implode(', ', $availableOptions).")";
$this->optionalArguments[$argName]= new InputArgument($argName,
InputArgument::OPTIONAL,
$description);
$this->commandAvailableOptions[$argName]= $availableOptions;
return $this;
}
/**
* Adds a required option.
* An option is that argument which receives a value.
* Example: create project demo
* Where 'project' is the option and 'demo' is its value.
*
* @param string $argName
* @param string $shortCut
* @param string $description
* @param mixed $default
* @param Array $availableOptions A list of available options
* @return MindCommand
*/
public function addRequiredOption($argName,
$shortCut=null,
$description='',
$default=null,
$availableOptions=null)
{
if($availableOptions)
$description.= "(".implode(', ', $availableOptions).")";
$this->requiredOptions[$argName]= new InputOption($argName,
$shortCut,
InputOption::PARAMETER_REQUIRED,
$description,
$default);
$this->commandAvailableOptions[$argName]= $availableOptions;
return $this;
}
/**
* Adds an optional option to the command.
* This is an option which, IF passed, receives a value.
*
* @param string $argName
* @param string $shortCut
* @param string $description
* @param mixed $default
* @param Array $availableOptions A list of available options.
* @return MindCommand
*/
public function addOptionalOption($argName,
$shortCut=null,
$description='',
$default=null,
$availableOptions=null)
{
if($availableOptions)
$description.= "(".implode(', ', $availableOptions).")";
$this->optionalOptions[$argName]= new InputOption($argName,
$shortCut,
InputOption::PARAMETER_OPTIONAL,
$description,
$default);
$this->commandAvailableOptions[$argName]= $availableOptions;
return $this;
}
/**
* Adds a flag to the command.
* A flag is just a boolean which defines an specific data.
* Example: show users -d
* Here, '-d' is the flag which defines the command to show detailed data about users.
*
* @param string $argName
* @param string $shortCut
* @param string $description
* @param Array $availableOptions A list of available options.
* @return MindCommand
*/
public function addFlag($argName,
$shortCut=null,
$description='',
$availableOptions=null)
{
if($availableOptions)
$description.= "(".implode(', ', $availableOptions).")";
$this->commandFlags[$argName]= new InputOption($argName,
$shortCut,
InputOption::PARAMETER_NONE,
$description);
$this->commandAvailableOptions[$argName]= $availableOptions;
return $this;
}
/**
* Sets the command's name.
* @param string $commandName
* @return MindCommand
*/
public function setCommandName($commandName)
{
$this->commandName= $commandName;
return $this;
}
public function setAdminAccess()
{
$this->adminOnly= true;
return $this;
}
/**
* Sets the command's description.
* @param string $description
* @return MindCommand
*/
public function description($description)
{
$this->description= $description;
return $this;
}
/**
* Sets the command's help message.
* @param string $helpContent
* @return MindCommand
*/
public function help($helpContent)
{
$this->helpContent= $helpContent;
return $this;
}
/**
* This method sets the action the command will call.
* You can pass an annonymous function to it or the name of a method INSIDE the command's class.
*
* @param string|function $action
* @return MindCommand
*/
public function setAction($action)
{
$this->commandAction= $action;
return $this;
}
/**
* Specifies the name of the file, included with the program
* @param String $fName
* @return MindCommand
*/
public function setFileName($fName)
{
$this->fileName= $fName;
return $this;
}
/**
* Gets the name of the file which the program is refered to
* @method getFileName
* @return String
*/
public function getFileName()
{
return $this->fileName!=null? $this->fileName: $this->getName();
}
/**
* Sets the restrict property
*
* @param Boolean $b
* @return MindCommand Itself
*/
public function setRestrict($b)
{
$this->restrict= $b;
return $this;
}
/**
* Construct
* @param String $name
*/
public function __construct($name = null)
{
parent::__construct($name);
}
/**
* Verifies if the user has already registered or not
* according to the specifications of each program
*
* @method verifyCredentials
* @return Boolean
*/
public function verifyCredentials()
{
if($this->restrict)
if(!MindUser::isIn())
{
Mind::write('not_allowed');
Mind::write('not_allowed_tip');
return false;
}
if($this->adminOnly && !MindUser::isAdmin())
{
Mind::write('mustBeAdmin');
return false;
}
return true;
}
/**
* Calls the pluggins that should run on
* specific already registered events
*
* @method runPlugins
* @param String $evt
* @return void
*/
public function runPlugins($evt)
{
if(isset(Mind::$pluginList[$this->name]))
{
foreach(Mind::$pluginList[$this->name][$evt] as $plugin)
{
if($plugin->active !== false)
$plugin->run($this);
}
}
}
/**
* Calls the program using the cosole interface
*
* @method execute
* @param Console\Input\InputInterface $input
* @param Console\Output\OutputInterface $output
* @return Boolean
*/
public function execute(Console\Input\InputInterface $input,
Console\Output\OutputInterface $output)
{
if(!$this->verifyCredentials())
return false;
foreach($input->getArguments() as $k=>$arg)
{
$this->$k= $arg;
}
foreach($input->getOptions() as $k=>$opt)
{
$this->$k= $opt;
}
$this->runAction();
}
/**
* Calls the program by the HTTP interface
* @method HTTPExecute
* @global Array $_REQ
* @return Boolean
*/
public function HTTPExecute()
{
GLOBAL $_REQ;
if($_REQ['env'] =='http')
{
if(!$this->verifyCredentials())
return false;
foreach($_REQ['data'] as $k=>$arg)
{
$this->$k= $arg;
}
$this->runAction();
}
}
/**
* function taken from: http://www.dasprids.de/blog/2008/08/22/getting-a-password-hidden-from-stdin-with-php-cli
* this method should read the passwords from console, not showing any character
* or replacing them by stars(asterisks)
* @method readPassword
* @param Boolan $stars if true, show an * for each typed char
* @return String password
*/
public static function readPassword($stars)
{
// Get current style
$oldStyle = shell_exec('stty -g');
if ($stars === false) {
shell_exec('stty -echo');
$password = rtrim(fgets(STDIN), "\n");
} else {
shell_exec('stty -icanon -echo min 1 time 0');
$password = '';
while (true) {
$char = fgetc(STDIN);
if ($char === "\n") {
break;
} else if (ord($char) === 127) {
if (strlen($password) > 0) {
fwrite(STDOUT, "\x08 \x08");
$password = substr($password, 0, -1);
}
} else {
fwrite(STDOUT, "*");
$password .= $char;
}
}
}
// Reset old style
shell_exec('stty ' . $oldStyle);
// Return the password
return $password;
}
/**
* This method will execute the plugins that should run AFTER
* the execution of the program, so, call parent::runAction AFTER
* each program::runAction command blocks
*/
public function runAction(){
$this->runPlugins('before');
foreach($this->commandAvailableOptions as $k=>$avOpts)
{
if($avOpts && !in_array(strtolower($this->$k),
array_map('strtolower', $avOpts)))
{
Mind::write('invalidOptionValue', true, $this->$k, $k);
return false;
}
}
// yeah, I know it looks a bit crazy!
if(is_string($this->commandAction))
$this->{$this->commandAction}();
else
call_user_func($this->commandAction, $this);
$this->runPlugins('after');
}
public function __set($what, $value)
{
$this->$what= $value;
}
}
Referência em uma Nova Issue Ver Git Blame Copiar Link Permanente