Comandos de Ubiquity

Nota

Esta parte es accesible desde las webtools, así que si creaste tu proyecto con la opción -a o con el comando create-project..

Comandos

Desde las webtools, activa la parte de comandos,

../_images/commands-elm.png

o vaya directamente a http://127.0.0.1:8090/Admin/commands.

Lista de comandos

Active la pestaña Comandos para obtener la lista de comandos devtools existentes.

../_images/commands-list.png

Info de comando

Es posible obtener ayuda sobre un comando (lo que produce un resultado equivalente a Ubiquity help cmdName).

../_images/command-help.png

Ejecución de comandos

Al pulsar el botón de ejecución de un comando, aparece un formulario para introducir los parámetros (o lo ejecuta directamente si no necesita ninguno).

../_images/command-run.png

Tras introducir los parámetros, la ejecución produce un resultado.

../_images/command-exec.png

Grupo de comandos

Volver a la pestaña Mis comandos: Es posible guardar una secuencia de comandos (con parámetros almacenados), y luego ejecutar la misma secuencia:

Creación de grupos

Haga clic en **añadir grupo de comandos*.

../_images/new-suite-btn.png

Añada los comandos deseados y modifique los parámetros:

../_images/new-commands-suite.png

La validación genera el grupo:

../_images/commands-suite-created.png

Ejecución del grupo de comandos

Al hacer clic en el botón de ejecución del grupo, se ejecuta la lista de comandos que contiene:

../_images/commands-suite-exec.png

Creación de comandos personalizados

Haga clic en el botón Crear comando devtools.

../_images/create-devtools-command-btn.png

Introduzca las características del nuevo comando:

  • Nombre del comando

  • El valor del comando: nombre del argumento principal

  • Los parámetros del comando: En caso de varios parámetros, utilice la coma como separador

  • Descripción del comando

  • Alias de los comandos: En caso de varios alias, utilice una coma como separador

../_images/create-command.png

Nota

Los comandos personalizados se crean en la carpeta app/commands del proyecto.

../_images/custom-command-exec.png

La clase generada:

app/commands/CreateArray.php
 1namespace commands;
 2
 3use Ubiquity\devtools\cmd\commands\AbstractCustomCommand;
 4use Ubiquity\devtools\cmd\ConsoleFormatter;
 5use Ubiquity\devtools\cmd\Parameter;
 6
 7class CreateArray extends AbstractCustomCommand {
 8
 9     protected function getValue(): string {
10             return 'jsonValue';
11     }
12
13     protected function getAliases(): array {
14             return array("createarray","arrayFromJson");
15     }
16
17     protected function getName(): string {
18             return 'createArray';
19     }
20
21     protected function getParameters(): array {
22             return ['f' => Parameter::create('fLongName', 'The f description.', [])];
23     }
24
25     protected function getExamples(): array {
26             return ['Sample use of createArray'=>'Ubiquity createArray jsonValue'];
27     }
28
29     protected function getDescription(): string {
30             return 'Creates an array from JSON and save to file';
31     }
32
33     public function run($config, $options, $what, ...$otherArgs) {
34             //TODO implement command behavior
35             echo ConsoleFormatter::showInfo('Run createArray command');
36     }
37}

El comando CreateArray implementado:

app/commands/CreateArray.php
 1namespace commands;
 2
 3use Ubiquity\devtools\cmd\commands\AbstractCustomCommand;
 4use Ubiquity\devtools\cmd\ConsoleFormatter;
 5use Ubiquity\devtools\cmd\Parameter;
 6use Ubiquity\utils\base\UFileSystem;
 7
 8class CreateArray extends AbstractCustomCommand {
 9
10     protected function getValue(): string {
11             return 'jsonValue';
12     }
13
14     protected function getAliases(): array {
15             return array(
16                     "createarray",
17                     "arrayFromJson"
18             );
19     }
20
21     protected function getName(): string {
22             return 'createArray';
23     }
24
25     protected function getParameters(): array {
26             return [
27                     'f' => Parameter::create('filename', 'The filename to create.', [])
28             ];
29     }
30
31     protected function getExamples(): array {
32             return [
33                     'Save an array in test.php' => "Ubiquity createArray \"{\\\"created\\\":true}\" -f=test.php"
34             ];
35     }
36
37     protected function getDescription(): string {
38             return 'Creates an array from JSON and save to file';
39     }
40
41     public function run($config, $options, $what, ...$otherArgs) {
42             echo ConsoleFormatter::showInfo('Run createArray command');
43             $array = \json_decode($what, true);
44             $error = \json_last_error();
45             if ($error != 0) {
46                     echo ConsoleFormatter::showMessage(\json_last_error_msg(), 'error');
47             } else {
48                     $filename = self::getOption($options, 'f', 'filename');
49                     if ($filename != null) {
50                             UFileSystem::save($filename, "<?php\nreturn " . var_export($array, true) . ";\n");
51                             echo ConsoleFormatter::showMessage("$filename succefully created!", 'success', 'CreateArray');
52                     } else {
53                             echo ConsoleFormatter::showMessage("Filename must have a value!", 'error');
54                     }
55             }
56     }
57}

Ejecución de comandos personalizados

El nuevo comando es accesible desde las devtools, siempre que esté en el proyecto:

Ubiquity help createArray
../_images/custom-command-help.png 
Ubiquity createArray "{\"b\":true,\"i\":5,\"s\":\"string\"}" -f=test.php
../_images/custom-command-devtools.png