Biblioteca Eliasis Complement
Eliasis Complement / Documentación · Versión 1.1.1
Introducción
- Nombre : Eliasis Complement
- Autor : Josantonius
- Soporte : https://github.com/eliasis-framework/complement/issues
- Licencia : MIT
Biblioteca PHP para agregar adición de complementos (componentes, plugins, módulos, plantillas) en Eliasis Framework.
Primeros pasos #volver arriba
Requisitos
Esta biblioteca es soportada por versiones de PHP 5.6 o superiores y es compatible con versiones de HHVM 3.0 o superiores.
Instalación
Puedes instalar Eliasis Complement en tu proyecto utilizando Composer:
composer require eliasis-framework/complement
El comando anterior sólo instalará los archivos necesarios, si prefieres descargar todo el código fuente (incluyendo tests, directorio vendor, excepciones no utilizadas, documentos...) puedes utilizar:
composer require eliasis-framework/complement --prefer-source
Estructura básica
Puedes agregar cuatro tipos de complementos en tu aplicación Eliasis; componentes, módulos, plugins y plantillas.
Para cargar complementos basta con agregarlos en sus directorios predeterminados y Eliasis se encargará de cargarlos:
- my-eliasis-app
- components
- config
- modules
- plugins
- public
- src
- templates
- my-eliasis-app.php
Y utilizar la clase del complemento en tu archivo.
/**
* my-eliasis-app.php
*/
use Eliasis\Complement\Type\Component;
use Eliasis\Complement\Type\Module;
use Eliasis\Complement\Type\Plugin;
use Eliasis\Complement\Type\Template;
Lo básico #volver arriba
Crear complementos
La estructura básica de un complemento en Eliasis consiste en un directorio que contiene un fichero de configuración con el mismo nombre que el directorio.
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
Los parámetros básicos de los archivos de configuración son los siguientes:
/**
* components/basic-component/basic-component.json
*/
{
"id": "BasicComponent",
"name": "Basic Component",
"version": "1.0.0",
"description": "Description for 'Basic Component'.",
"state": "inactive",
"category": "basic-component",
"url": "//github.com/Josantonius/"
}
/**
* modules/basic-module/basic-module.json
*/
{
"id": "BasicModule",
"name": "Basic Module",
"version": "1.0.0",
"description": "Description for 'Basic Module'.",
"state": "active",
"category": "basic-module",
"url": "//github.com/Josantonius/"
}
/**
* plugins/basic-plugin/basic-plugin.json
*/
{
"id": "BasicPlugin",
"name": "Basic Plugin",
"version": "1.0.0",
"description": "Description for 'Basic Plugin'.",
"state": "uninstalled",
"category": "basic-plugin",
"url": "//github.com/Josantonius/"
}
/**
* templates/basic-template/basic-template.json
*/
{
"id": "BasicTemplate",
"name": "Basic Template",
"version": "1.0.0",
"description": "Description for 'Basic Template'.",
"state": "inactive",
"category": "basic-template",
"url": "//github.com/Josantonius/"
}
Opcionalmente puedes añadir algunos campos adicionales:
/**
* modules/basic-module/basic-module.json
*/
{
"id": "BasicModule",
"name": "Basic Module",
"version": "1.0.0",
"description": "Description for 'Basic Module'.",
"state": "active",
"category": "basic-module",
"url": "//github.com/Josantonius/",
"author": "Josantonius",
"author-url": "//josantonius.com/",
"license": "GPL-2.0+",
"extra": {
"a-custom-field": "Value",
"another-custom-field": "Value",
"more-custom-fields": "Value"
}
}
Estos parámetros estarán disponibles en las opciones del complemento.
Temas referidos en esta sección:
ID del complemento
El ID admite las siguientes convenciones de clase: UpperCamelCase, lowerCamelCase & snake_case.
Los identificadores de complementos permiten interactuar con múltiples complementos en aplicaciones Eliasis, evitando colisiones y facilitando el acceso a ellos desde cualquier lugar.
Accediendo a complementos
Para saltar de un complemento a otro, tan solo tienes que pasar el ID del complemento como método y acceder a sus métodos disponibles.
/**
* my-eliasis-app.php
*/
use Eliasis\Complement\Type\Component;
use Eliasis\Complement\Type\Module;
use Eliasis\Complement\Type\Plugin;
use Eliasis\Complement\Type\Template;
Component::BasicComponent()->getCurrentID(); // BasicComponent
Module::BasicModule()->getCurrentID(); // BasicModule
Plugin::BasicPlugin()->getCurrentID(); // BasicPlugin
Template::BasicTemplate()->getCurrentID(); // BasicTemplate
Para acceder a complementos de diferentes aplicaciones tan solo tienes que establecer el ID actual para la aplicación y acceder a complemento como vimos anteriormente.
/**
* my-eliasis-app.php
*/
App:setCurrentID('MyFirstApp');
// Se accede al componente BasicComponent de la aplicación MyFirstApp.
Component::BasicComponent()->getCurrentID();
// Se accede al componente BasicComponent de la aplicación MySecondApp.
App:setCurrentID('MySecondApp');
Component::BasicComponent()->getCurrentID();
En el caso de solo utilizar una aplicación en el sitio web, no hay necesidad de especificar ni establecer el ID de la aplicación.
Métodos vistos en esta sección:
Complementos remotos
También puedes cargar complementos remotos en una aplicación con Eliasis.
/**
* https://site.com/remote-complement.json
*/
{
"id": "RemoteComplement",
"name": "Remote Complement",
"version": "3.0.0",
"description": "Description for 'Remote Complement'.",
"state": "uninstalled",
"category": "remote-complement",
"url": "//github.com/Josantonius/",
"url-import": "https://site.com/master/",
"installation-files": {
"remote-complement": {
"0": "LICENSE",
"1": "composer.json",
"2": "remote-complement.json",
"config": [],
"public": [],
"src": []
}
}
}
Module::load('https://site.com/remote-complement.json');
Para instalar complementos remotos deberás especificar la url del directorio base desde el que se importará (url-import) y la estructura de los ficheros (installation-files) a importar.
Una vez cargado el complemento puedes instalarlo utilizando el método install().
Module::RemoteComplement()->install();
Y esto crearía un módulo compuesto por tres archivos y tres directorios:
- modules
- remote-complement
- config
- public
- src
- composer.json
- LICENSE
- remote-complement.json
- remote-complement
Métodos referidos en esta sección:
Mostrando complementos
Eliasis Complement utiliza el componente vue-module-manager para mostrar los complementos en pantalla:
Tan solo tendrás que agregar los estilos y scripts en el directorio que desees y utilizar el método render:
Module::render();
Métodos referidos en esta sección:
Puedes ampliar información en las secciones:
Archivos de configuración
El complemento recopilará todos los archivos de configuración encontrados en el directorio "config":
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
Archivos de configuración deben retornar un array indexado y podrán contener cualquier tipo de dato:
/**
* modules/basic-module/config/settings.php
*/
return [
'slug' => 'basic-module',
'email' => [
'rol' => [
'admin' => 'admin@site.com',
'editor' => 'editor@site.com'
]
]
];
/**
* modules/basic-module/config/paths.php
*/
use Eliasis\Framework\App;
return [
'path' => [
'layout' => App::MODULES() . 'src/template/layout/',
'page' => App::MODULES() . 'src/template/page/',
],
];
Temas referidos en esta sección:
Obtener opciones
Para obtener los parámetros de configuración desde el complemento:
App::getOption('slug');
App::getOption('email');
App::getOption('email', 'rol');
App::getOption('email', 'rol', 'admin');
Pasando el ID de la aplicación como método y usando el método getOption():
Métodos vistos en esta sección:
Controladores
Los controladores deben ser creados en el directorio "src/Controller" de la aplicación:
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- src
- Controller
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
La estructura básica de un controlador en Eliasis Complement es la siguiente:
/**
* basic-module/src/Controller/Home.php
*/
namespace BasicModule\Controller;
use Eliasis\Framework\Controller;
class Home extends Controller
{
}
Instancias de controladores
Puedes acceder fácilmente a la instancia de un controlador desde cualquier punto de la aplicación utilizando el método "getControllerInstance()".
El método "getControllerInstance" utiliza los espacios de nombre almacenados en el índice "namespaces" para obtener las instancias de los controladores, por lo tanto deben haber sido agregados anteriormente en el archivo "config/namespaces.php":
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- src
- Controller
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
/**
* basic-module/config/namespaces.php
*/
return [
'namespaces' => [
'controller' => 'BasicModule\\Controller\\'
],
];
O haber sido añadido anteriormente a través del método "App::setOption()":
Module::BasicModule()->setOption('namespaces', [
'controller' => 'App\\Controller\\'
];
Para obtener la instancia simplemente tienes que indicar el nombre de la clase del controlador y el ID del namespace. Este último parámetro es opcional, aunque es recomendable utilizarlo cuando se repiten nombres de clase:
Module::BasicModule()->getControllerInstance('Home');
Module::BasicModule()->getControllerInstance('Home', 'controller');
Métodos vistos en esta sección:
Ganchos de acción
Por defecto, cuando un complemento cambia de estado, se ejecutan los siguientes métodos:
- · activation(): cuando un complemento es activado.
- · deactivation(): cuando un complemento es desactivado.
- · installation(): cuando un complemento es instalado.
- · uninstallation(): cuando un complemento es desinstalado.
Eliasis buscará estos métodos en el controlador "Launcher". Para utilizar otro controlador, tan solo tienes que especificarlo en la configuración.
/**
* modules/basic-module/basic-module.json
*/
{
"id": "BasicModule",
"name": "Basic Module",
"version": "1.0.0",
"description": "Description for 'Basic Module'.",
"state": "active",
"category": "basic-module",
"url": "//github.com/Josantonius/",
"author": "Josantonius",
"author-url": "//josantonius.com/",
"license": "GPL-2.0+",
"hooks-controller": "Hook",
"extra": {
"a-custom-field": "Value",
"another-custom-field": "Value",
"more-custom-fields": "Value"
}
}
Y agregas el controlador:
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- src
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
El contenido del archivo se vería de la siguiente manera:
/**
* modules/basic-module/src/Controller/Hook.php
*/
namespace BasicModule\Controller;
use Eliasis\Framework\Controller;
/**
* Hook controller.
*/
class Hook extends Controller
{
/**
* Actions for activation hook.
*/
public function activation() { }
/**
* Actions for deactivation hook.
*/
public function deactivation() { }
/**
* Actions for installation hook.
*/
public function installation() { }
/**
* Actions for uninstallation hook.
*/
public function uninstallation() { }
}
Temas referidos en esta sección:
Modelos
Los modelos deben ser creados en el directorio "src/Model" del complemento, estar al mismo nivel que el controlador y tener el mismo nombre:
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- src
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
La estructura básica de un modelo es la siguiente:
/**
* basic-module/src/Model/Home.php
*/
namespace BasicModule\Model;
use Eliasis\Framework\Model;
class Home extends Model
{
}
Al instanciar un controlador, el modelo es instanciado automáticamente si es que existe. Puedes acceder a la instancia del modelo desde el controlador utilizando el atributo "model" en los métodos del controlador:
/**
* basic-module/src/Controller/Home.php
*/
public function createTables()
{
return $this->model->createTables();
}
Plantillas
Las plantillas pueden ser creadas en cualquier directorio aunque se recomienda hacerlo en el directorio "src/template":
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- src
- Controller
- Model
- template
- layout
- page
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
Estructura básica de las plantillas:
/**
* basic-module/src/template/layout/header.php
*
* Header content.
*/
/**
* basic-module/src/template/page/home.php
*
* Home page content.
*/
/**
* basic-module/src/template/layout/footer.php
*
* Footer content.
*/
Puedes acceder a la instancia de la vista desde el controlador utilizando el atributo "view" en los métodos del controlador.
Utiliza el método "renderizate" para cargar las plantillas y enviarle parámetros personalizados:
/**
* basic-module/src/Controller/Home.php
*/
public function render()
{
$page = Module::BasicModule->getOption('page');
$layout = Module::BasicModule->getOption('layout');
$this->view->renderizate($layout, 'header', ['data' => 'Header']);
$this->view->renderizate($page, 'home', ['data' => 'Home']);
$this->view->renderizate($layout, 'footer', ['data' => 'Footer']);
}
Desde cada plantilla podrás utilizar las opciones enviadas desde el método "renderizate" a través del método "View::getOption()":
/**
* basic-module/src/template/layout/header.php
*/
use Eliasis\Framework\View;
View::getOption('data'); // Header
/**
* basic-module/src/template/page/home.php
*/
use Eliasis\Framework\View;
View::getOption('data'); // Home
/**
* basic-module/src/template/layout/footer.php
*/
use Eliasis\Framework\View;
View::getOption(); // ['data' => 'Footer']
Métodos vistos en esta sección:
Rutas predefinidas
Lista de "constantes" para manejo de ruta:
App::ROOT(); # /my-eliasis-app/
App::CORE(); # /my-eliasis-app/vendor/eliasis-framework/eliasis/
App::PUBLIC(); # /my-eliasis-app/public/
App::TEMPLATES(); # /my-eliasis-app/templates/
App::MODULES(); # /my-eliasis-app/modules/
App::PLUGINS(); # /my-eliasis-app/plugins/
App::COMPONENTS(); # /my-eliasis-app/components/
URLs predefinidas
Lista de "constantes" para manejo de URLs:
App::PUBLIC_URL(); # https://site.com/my-eliasis-app/public/
App::TEMPLATES_URL(); # https://site.com/my-eliasis-app/templates/
App::MODULES_URL(); # https://site.com/my-eliasis-app/modules/
App::PLUGINS_URL(); # https://site.com/my-eliasis-app/plugins/
App::COMPONENTS_URL(); # https://site.com/my-eliasis-app/components/
Global methods #back to top
load()
Este método cargará un complemento a partir de su archivo de configuración. Útil para cargar complementos remotos en aplicaciones con Eliasis.
Component::load($configurationFile);
Module::load($configurationFile);
Plugin::load($configurationFile);
Template::load($configurationFile);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $configurationFile | Ruta o url hacia el archivo de configuración del complemento. | string | sí |
@return (boolean true)
Cargar complemento remoto:
Module::load('https://site.com/remote-complement.json');
Cargar complemento local:
Module::load('var/www/site.com/remote-complement.json');
Puedes ampliar información en las secciones:
exists()
Validar si existe un complemento.
Component::exists($complementID);
Module::exists($complementID);
Plugin::exists($complementID);
Template::exists($complementID);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $complementID | ID del complemento. | string | sí |
@return (boolean)
Comprobar si existe el módulo BasicModule:
Module::exists('BasicModule');
getList()
Obtener lista de componentes/plugins/módulos/plantillas.
Component::list($filter, $sort);
Module::list($filter, $sort);
Plugin::list($filter, $sort);
Template::list($filter, $sort);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $filter | Filtrar por categoría. | string | no | 'all' |
| $sort | Nombre de la función de ordenamiento PHP para ordenar la lista de complementos. | string | no | 'asort' |
@return (array) → Lista de complementos
Obtener una lista de complementos con filtros y ordenamiento por defecto:
Module::getList();
Obtener lista de complementos filtrando por categoría:
Module::getList('basic-module');
Obtener lista de complementos y filtrar por:
Module::getList('all', 'asort');
Module::getList('all', 'arsort');
Module::getList('all', 'krsort');
Module::getList('all', 'ksort');
Module::getList('all', 'rsort');
Module::getList('all', 'shuffle');
Module::getList('all', 'sort');
script()
Establecer la ruta donde guardar el script y obtener su url. Utilizado por el método render().
Component::script($pathUrl, $vue, $vueResource);
Module::script($pathUrl, $vue, $vueResource);
Plugin::script($pathUrl, $vue, $vueResource);
Template::script($pathUrl, $vue, $vueResource);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $pathUrl | Ruta url donde se crearán y cargarán los archivos JavaScript. | string | no | null |
| $vue | Incluir Vue.js en el script. | boolean | no | true |
| $vueResource | Incluir vue-resource en el script. | boolean | no | true |
@return (string) → Url del archivo JavaScript
Establecer y obtener url para script completo.
Si no se especifica ninguna ruta url, se utilizará la establecida en la configuración (path-url) de los archivos de configuración (si es que existe).
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- src
- Controller
- Model
- template
- layout
- page
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
/**
* modules/basic-module/config/urls.php
*/
return [
'path-url' => [
'js' => 'https://example.org/public/js/'
]
];
Module::script();
// Return: https://example.org/public/js/vue+vue-resource+eliasis-complement.min-1-1-1.js
Establecer y obtener URL utilizando una ruta personalizada:
Module::script('https://example.org/public/js/');
// Return: https://example.org/public/js/vue+vue-resource+eliasis-complement.min-1-1-1.js
Establecer y obtener URL sin incluir en el archivo Vue.js ni VueResource.js:
Module::script(null, false, false);
// Return: https://example.org/public/js/eliasis-complement.min-1-1-1.js
Establecer y obtener URL incluyendo Vue.js y sin incluir VueResource.js:
Module::script(null, true, false);
// Return: https://example.org/public/js/vue+eliasis-complement.min-1-1-1.js
Establecer y obtener URL sin incluir Vue.js e incluyendo VueResource.js:
Module::script(null, false, true);
// Return: https://example.org/public/js/vue-resource+eliasis-complement.min-1-1-1.js
style()
Establecer y obtener URL hacia el archivo de estilos. Usado por el método render().
Component::style($pathUrl);
Module::style($pathUrl);
Plugin::style($pathUrl);
Template::style($pathUrl);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $pathUrl | Ruta url donde se crearán y cargarán el archivo de estilos. | string | no | null |
@return (string) → Url hacia los estilos
Establecer y obtener URL hacia el archivo de estilos.
Si no se especifica ninguna ruta url, se utilizará la establecida en la configuración (path-url) de los archivos de configuración (si es que existe):
/**
* modules/basic-module/config/urls.php
*/
return [
'path-url' => [
'css' => 'https://example.org/public/css/',
'js' => 'https://example.org/public/js/'
]
];
Module::style();
// Return: https://example.org/public/css/eliasis-complement.min-1-1-1.css
Establecer y obtener URL hacia el archivo de estilos with custom path url:
Module::style('https://example.org/public/css/');
// Return: https://example.org/public/css/eliasis-complement.min-1-1-1.css
render()
Mostrar complementos.
Component::render($filter, $remote, $sort, $translations);
Module::render($filter, $remote, $sort, $translations);
Plugin::render($filter, $remote, $sort, $translations);
Template::render($filter, $remote, $sort, $translations);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $filter | Categoría de los complementos a mostrar. | string | no | 'all' |
| $remote | Urls hacia los archivos de configuración de los complementos remotos. | array | no | 'asort' |
| $sort | ombre de la función de ordenamiento PHP para ordenar la lista de complementos. | string | no | null |
| $translations | Traducciones para los textos de los botones. | array | no | null |
@return (boolean true)
Mostrar complementos locales especificando una categoría a filtrar:
Module::render('basic-module');
Mostrar complementos locales y añadir también complementos remotos:
Module::render(
'basic-module',
[
'ComplementOne' => http:/example.org/complement-one.json',
'ComplementTwo' => http:/example.org/complement-two.json',
'ComplementThree' => http:/example.org/complement-three.json'
]
);
Mostrar complementos locales y ordernarlos por:
Module::render('all', null, 'asort');
Module::render('all', null, 'arsort');
Module::render('all', null, 'krsort');
Module::render('all', null, 'ksort');
Module::render('all', null, 'rsort');
Module::render('all', null, 'shuffle');
Module::render('all', null, 'sort');
Mostrar complementos locales y establecer traducciones en español para los botones:
Module::render(
'all',
null,
'asort',
[
'active' => 'activo',
'activate' => 'activar',
'install' => 'instalar',
'update' => 'actualizar',
'uninstall' => 'desinstalar'
]
);
setCurrentID()
Seleccionar aplicación estableciendo su ID.
Component::setCurrentID($id);
Module::setCurrentID($id);
Plugin::setCurrentID($id);
Template::setCurrentID($id);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $id | ID de la aplicación. | string | sí |
@return (boolean)
Define the current application ID:
Module::setCurrentID('BasicModule');
Module::setCurrentID('RemoteComplement');
Puedes ampliar información en las secciones:
getCurrentID()
Obtener el ID de la aplicación actual.
Component::getCurrentID();
Module::getCurrentID();
Plugin::getCurrentID();
Template::getCurrentID();
@return (string) → ID de la aplicación.
Obtener el ID de la aplicación actual:
Module::getCurrentID();
Puedes ampliar información en las secciones:
getLibraryVersion()
Obtener la versión actual de Eliasis Complement.
Component::getLibraryVersion();
Module::getLibraryVersion();
Plugin::getLibraryVersion();
Template::getLibraryVersion();
Obtener la versión actual de Eliasis Complement:
Module::getLibraryVersion();
getInstance()
Obtener instancia del complemento.
Component::getInstance();
Module::getInstance();
Plugin::getInstance();
Template::getInstance();
Obtener instancia del complemento:
Module::getInstance();
Métodos de complementos #volver arriba
setOption()
Definir opciones para la aplicación.
Component::BasicComponent->setOption($option, $value);
Module::BasicModule->setOption($option, $value);
Plugin::BasicPlugin->setOption($option, $value);
Template::BasicTemplate->setOption($option, $value);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $option | Nombre para la opción. | string | sí | |
| $value | Valor de la opción. | mixed | sí |
@return (mixed) → Option set.
Establecer opciones:
Module::BasicModule->setOption('string-test', 'string');
Module::BasicModule->setOption('int-test', 8);
Module::BasicModule->setOption('bool-test', true);
Module::BasicModule->setOption('array-test', []);
Puedes ampliar información en las secciones:
getOption()
Obtener opciones de la aplicación.
Component::BasicComponent->getOption(...$params);
Module::BasicModule->getOption(...$params);
Plugin::BasicPlugin->getOption(...$params);
Template::BasicTemplate->getOption(...$params);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $params | Índice o índices del parámetro que se desea obtener. | array | sí |
@return (mixed) → Parámetros solicitados.
Obtener opciones:
odule::BasicModule->getOption('index');
Module::BasicModule->getOption('index', 'index-1');
Module::BasicModule->getOption('index', 'index-1', 'index-2');
Puedes ampliar información en las secciones:
getControllerInstance()
Obtener la instancia del controlador.
Component::BasicComponent->getControllerInstance($class, $namespace);
Module::BasicModule->getControllerInstance($class, $namespace);
Plugin::BasicPlugin->getControllerInstance($class, $namespace);
Template::BasicTemplate->getControllerInstance($class, $namespace);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $class | Nombre de la clase | string | sí | |
| $namespace | Índice del namespace. | string | no | '' |
@return (object|false) → Instancia de la clase o falso.
Obtener la instancia del controlador:
Module::BasicModule->getControllerInstance('Home');
Module::BasicModule->getControllerInstance('Home', 'controller');
Puedes ampliar información en las secciones:
setAction()
Establecer acción para el complemento.
Component::BasicComponent->setAction($action);
Module::BasicModule->setAction($action);
Plugin::BasicPlugin->setAction($action);
Template::BasicTemplate->setAction($action);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $action | Acción para el complemento. | string | sí |
@return (string) → Acción establecida.
Establecer acción de activación para el comlemento:
Module::BasicModule->setAction('activation');
Establecer acción de desactivación para el comlemento:
Module::BasicModule->setAction('deactivation');
Establecer acción de instalación para el comlemento:
Module::BasicModule->setAction('installation');
Establecer acción de desinstalación para el comlemento:
Module::BasicModule->setAction('uninstallation');
getAction()
Obtener acción desde el estado del complemento.
Component::BasicComponent->getAction($action);
Module::BasicModule->getAction($action);
Plugin::BasicPlugin->getAction($action);
Template::BasicTemplate->getAction($action);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $state | Estado del complemento. | string | sí |
@return (string) → Acción establecida.
Obtener acción del complemento a partir del estado:
Module::BasicModule->getAction('active');
doAction()
Ejecutar ganchos de acción.
Component::BasicComponent->doAction($action);
Module::BasicModule->doAction($action);
Plugin::BasicPlugin->doAction($action);
Template::BasicTemplate->doAction($action);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $action | Acción a ajecutar. | string | sí |
@return (boolean)
Ejecutar acción para gancho de activación:
Module::BasicModule->doAction('activation');
Ejecutar acción para gancho de desactivación:
Module::BasicModule->doAction('deactivation');
Ejecutar acción para gancho de instalación:
Module::BasicModule->doAction('installation');
Ejecutar acción para gancho de desinstalación:
Module::BasicModule->doAction('uninstallation');
setState()
Establecer estado del complemento.
Component::BasicComponent->setState($state);
Module::BasicModule->setState($state);
Plugin::BasicPlugin->setState($state);
Template::BasicTemplate->setState($state);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $state | Estado a establecer. | string | sí |
@return (string) → Estado establecido.
Establecer estado del complemento a activo:
Module::BasicModule->setState('active');
Establecer estado del complemento a inactivo:
Module::BasicModule->setState('inactive');
Establecer estado del complemento a instalado:
Module::BasicModule->setState('installed');
Establecer estado del complemento a desinstalado:
Module::BasicModule->setState('uninstalled');
getState()
Obtener estado del complemento.
Component::BasicComponent->getState();
Module::BasicModule->getState();
Plugin::BasicPlugin->getState();
Template::BasicTemplate->getState();
@return (string) → Estado del complemento.
Obtener el estado actual del coplemento:
Module::BasicModule->getState();
getStates()
Obtener estados del complemento.
Component::BasicComponent->getStates($action);
Module::BasicModule->getStates($action);
Plugin::BasicPlugin->getStates($action);
Template::BasicTemplate->getStates($action);
@return (array) → Estado y acción del complemento.
Obtener estado y acción actual del complemento:
Module::BasicModule->getStates();
changeState()
Cambiar estado del complemento.
Component::BasicComponent->changeState();
Module::BasicModule->changeState();
Plugin::BasicPlugin->changeState();
Template::BasicTemplate->changeState();
@return (string) → Nuevo estado.
Cambiar el estado del complemento cuando el estado actual es activo:
Module::BasicModule->changeState(); // inactive
Cambiar el estado del complemento cuando el estado actual es inactivo:
Module::BasicModule->changeState(); // active
Cambiar el estado del complemento cuando el estado actual es desinstalado:
Module::BasicModule->changeState(); // installed
Cambiar el estado del complemento cuando el estado actual es instalado:
Module::BasicModule->changeState(); // inactive
Cambiar el estado del complemento cuando el estado actual es desactualizado:
Module::BasicModule->changeState(); // updated
Cambiar el estado del complemento cuando el estado actual es actualizado:
Module::BasicModule->changeState(); // active
install()
Instalar complemento remoto.
Component::RemoteComplement->install();
Module::RemoteComplement->install();
Plugin::RemoteComplement->install();
Template::RemoteComplement->install();
@return (boolean)
Instalar complemento remoto:
Module::RemoteComplement->install();
remove()
Eliminar complemento.
Component::BasicComponent->remove();
Module::BasicModule->remove();
Plugin::BasicPlugin->remove();
Template::BasicTemplate->remove();
@return (boolean true)
Eliminar complemento:
Module::BasicModule->remove();
hasNewVersion()
Comprobar si hay nueva versión para el complemento.
Component::RemoteComplement->hasNewVersion();
Module::RemoteComplement->hasNewVersion();
Plugin::RemoteComplement->hasNewVersion();
Template::RemoteComplement->hasNewVersion();
@return (boolean)
Comprobar si hay nueva versión para el complemento:
Module::RemoteComplement->hasNewVersion();
getRepositoryVersion()
Obtener la versión actual del complemento.
Component::getRepositoryVersion->getRepositoryVersion();
Module::getRepositoryVersion->getRepositoryVersion();
Plugin::getRepositoryVersion->getRepositoryVersion();
Template::getRepositoryVersion->getRepositoryVersion();
@return (string) → Versión actual del repositorio.
Obtener la versión actual del complemento:
Module::getRepositoryVersion->getRepositoryVersion();
Clase View #volver arriba
View::getInstance()
Obtener instancia de la vista.
View::getInstance();
@return (object)
Obtener instancia de la vista:
View::getInstance();
View::addHeader()
Agregar encabezado HTTP al array de encabezados.
View::addHeader($header);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $header | Encabezados HTTP. | string | sí |
@return (boolean true)
Agregar encabezado:
View::addHeader('HTTP/1.0 404 Not Found');
Puedes ampliar información en las secciones:
View::addHeaders()
Añadir un array con encabezados a la vista.
View::addHeaders($headers);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $headers | Encabezados HTTP. | array | sí |
@return (boolean true)
AAgregar encabezados:
View::addHeaders([
'WWW-Authenticate: Negotiate',
'HTTP/1.0 404 Not Found'
]);
Puedes ampliar información en las secciones:
View::sendHeaders()
Enviar encabezados.
View::sendHeaders();
@return (boolean)
Puedes ampliar información en las secciones:
View::renderizate()
Imprimir plantillas.
View::renderizate($path, $file, $data);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $path | Ruta del archivo. | string | sí | |
| $file | Nombre del archivo. | string | sí | |
| $data | Opciones para la vista. | array | no | null |
@return (boolean true)
Imprimir plantilla:
View::renderizate('path/to/file', 'template-name');
Imprimir plantilla con parámetros personalizados:
View::renderizate(
'path/to/file',
'template-name',
['test' => 'value']
););
Puedes ampliar información en las secciones:
View::getOption()
Obtener opciones.
View::getOption(...$params);
| Atributo | Descripción | Tipo de dato | Requerido | Por defecto |
|---|---|---|---|---|
| $params | Índice o índices del parámetro que se desea obtener. | array | sí |
@return (mixed) → Parámetros solicitados.
Get options:
View::getOption('index');
View::getOption('index', 'index-1');
View::getOption('index', 'index-1', 'index-2');
Puedes ampliar información en las secciones:
Bibliotecas adicionales #volver arriba
Eliasis Framework está enfocado en la escalabilidad, permitiéndote desarrollar desde una aplicación con un simple controlador, hasta un sistema completo.
Para ello pone a disposición una serie de bibliotecas opcionales que al instalarlas en tu proyecto se integran en el núcleo de Eliasis:
Asset
Biblioteca para manejo de estilos y scripts; añadir, minimizar, unificar e imprimir.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Asset
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- public
- css
- js
- src
- Controller
- Model
- template
- layout
- page
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
Añadir scripts y estilos a la configuración del complemento:
/**
* basic-module/config/assets.php
*/
use Eliasis\Complement\Type\Module;
$public = App::PUBLIC_URL() . 'modules/basic-module/public/;
return [
'assets' => [
'js' => [
'complements' => [
'name' => 'complements',
'url' => Module::script($public),
'attr' => 'defer',
'version' => '1.1.0',
'footer' => true
],
'myCustomScript' => [
'name' => 'myCustomScript',
'url' => $public . 'js/scripts.js',
'attr' => 'defer',
'version' => '1.1.3',
'footer' => false
]
],
'css' => [
'complements' => [
'name' => 'complements',
'url' => Module::style($public),
'version' => '1.1.0'
],
'myCustomStyle' => [
'name' => 'myCustomStyle',
'url' => $public . 'css/styles.css',
'version' => '1.1.1'
]
]
]
];
Agregar estilos:
/**
* basic-module/public/css/styles.css
*/
/**
* basic-module/src/Controller/Home.php
*/
use Josantonius\Asset\Asset;
public function css()
{
Asset::add('style',
App::assets('css')['complements']
);
Asset::add('style',
App::assets('css')['myFirstStyle']
);
}
Agregar scripts:
/**
* basic-module/public/js/scripts.js
*/
/**
* basic-module/src/Controller/Home.php
*/
use Josantonius\Asset\Asset;
public function js()
{
Asset::add('script',
App::assets('js')['complements']
);
Asset::add('script',
App::assets('js')['myFirstScript']
);
}
Para minimizar y/o unificar scripts y estilos basta con colocar el siguiente comando antes de ser agregados:
/**
* basic-module/my-custom-app.php
*/
use Josantonius\Asset\Asset;
$public = App::PUBLIC_URL();
Asset::unify('UniqueID', $public . '/', true);
Cookie
Biblioteca para el manejo de cookies.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Cookie
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Curl
Biblioteca PHP para hacer peticiones HTTP a través de cURL.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Curl
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Database
SQL database management library.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Database
Eliasis conectará con la base de datos utilizando la primera configuración encontrada en el parámetro "db" de la configuración de la aplicación:
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- public
- css
- js
- src
- Controller
- Model
- template
- layout
- page
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
/**
* config/database.php
*/
return [
'db' => [
'app' => [
'provider' => 'PDOprovider',
'host' => 'localhost',
'user' => 'db_user',
'name' => 'db_name',
'password' => 'db_password',
'settings' => ['charset' => 'utf8'],
],
'api-rest' => [
'provider' => 'PDOprovider',
'host' => 'localhost',
'user' => 'db_user',
'name' => 'db_name',
'password' => 'db_password',
'settings' => ['charset' => 'utf8'],
],
],
];
Puedes acceder a la instancia de la base de datos utilizando el atributo "db" en los métodos del modelo. Para cambiar la conexión basta con utilizar el método "changeDatabaseConnection()" del modelo.
/**
* src/Model/Home.php
*/
namespace App\Model;
use Eliasis\Framework\Model;
class Home extends Model
{
public function createTables()
{
$params = [
'id' => 'INT(6) PRIMARY KEY',
'name' => 'VARCHAR(30) NOT NULL',
'email' => 'VARCHAR(50)'
];
$this->db->create($params)
->table('test')
->execute();
$this-model->changeDatabaseConnection('api-rest');
$this->db->create($params)
->table('test_two')
->foreing('id')
->reference('id')
->on('test')
->actions('ON DELETE CASCADE ON UPDATE CASCADE')
->engine('innodb')
->charset('utf8')
->execute();
}
}
ErrorHandler
Biblioteca para manejar excepciones y errores.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/ErrorHandler
Esta biblioteca es instanciada por Eliasis cuando se encuentra instalada.
Puedes establecer métodos personalizados que se llamarán cuando haya algún error o excepción:
/**
* basic-module/my-custom-app.php
*/
$instance = Module::BasicModule()->getControllerInstance('Home', 'controller');
$method = 'errorHandler';
ErrorHandler::setCustomMethod($instance, $method);
File
Biblioteca para manejo de archivos.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/File
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Hook
Biblioteca para manejo de ganchos de acción.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Hook
Al instalar esta biblioteca, Eliasis cargará los ganchos de acción que se encuentren en el index "hooks" de los archivos de configuración:
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- public
- css
- js
- src
- Controller
- Model
- template
- layout
- page
- basic-module.json
- basic-module
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
- components
/**
* basic-module/config/set-hooks.php
*/
use Eliasis\Complement\Type\Module;
$namespace = Module::BasicModule()->getOption('namespaces', 'controller');
$class = $namespace . 'Home';
return [
'hooks' => [
['header', [$class, 'header'], 8, 0],
['footer', [$class, 'footer'], 8, 0],
['css', [$class, 'css'], 8, 0],
['js', [$class, 'js'], 8, 0],
],
];
Se agregan los métodos al controlador:
/**
* basic-module/src/Controller/Home.php
*/
public function header()
{
return '
Y se ejecutan en cualquier punto de la aplicación:
/**
* basic-module/src/template/layout/header.php
*/
use Eliasis\Framework\View;
use Josantonius\Hook\Hook;
Hook::doAction('css');
Hook::doAction('header');
View::getOption('data');
/**
* basic-module/src/template/page/home.php
*/
use Eliasis\Framework\View;
use Josantonius\Hook\Hook;
Hook::doAction('home');
View::getOption('data');
/**
* src/template/layout/footer.php
*/
use Eliasis\Framework\View;
use Josantonius\Hook\Hook;
Hook::doAction('footer');
Hook::doAction('js');
View::getOption('data');
HTTPStatusCode
Biblioteca para obtener significado de códigos de estado de respuesta HTTP.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/HTTPStatusCode
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Ip
Biblioteca para obtener la IP del usuario.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Ip
Y para obtener la IP del usuario, simplemente:
App::IP();
Json
Biblioteca para la gestión de archivos JSON.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Json
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
LanguageCode
Lista de 217 códigos de idioma: ISO 639-
Para instalar esta biblioteca, simplemente:
composer require Josantonius/LanguageCode
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
LoadTime
Calcular tiempo de carga de páginas o scripts.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/LoadTime
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Logger
Biblioteca para crear logs fácilmente y almacenarlos en formato JSON.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Logger
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
MimeType
Biblioteca para obtener encabezados MIME y extensiones a partir de ellos.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/MimeType
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Request
Biblioteca para manejo de peticiones.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Request
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Router
Biblioteca para manejo de rutas.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Router
Al instalar esta biblioteca, Eliasis cargará las rutas que se encuentren en el index "routes" de los archivos de configuración:
- my-eliasis-app
- components
- basic-component
- config
- modules
- basic-module
- config
- public
- css
- js
- src
- Controller
- Model
- template
- layout
- page
- basic-module.json
- plugins
- basic-plugin
- public
- src
- templates
- basic-template
- my-eliasis-app.php
/**
* basic-module/config/set-routes.php
*/
use Eliasis\Complement\Type\Module;
$namespace = Module::BasicModule()->getOption('namespaces', 'controller');
return [
'routes' => [
'my-route/' => $namespace . 'Home@render'
],
];
Se agrega el método al controlador:
/**
* basic/src/Controller/Home.php
*/
namespace BasicModule\Controller;
use Eliasis\Framework\Controller;
use Josantonius\Asset\Asset;
class Home extends Controller
{
public function header()
{
return '
Al acceder a la URL "https://site.com/my-route/" se ejecutará el método "home" y este ejecutará el método "render".
Session
Biblioteca para el manejo de sesiones.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Session
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Str
Biblioteca para manejo de strings.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Str
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Url
Biblioteca para manipulación de urls.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/Url
Esta biblioteca viene integrada en el núcleo de Eliasis.
WordPress libraries #volver arriba
Serie de bibliotecas opcionales para WordPress que puedes integrar en Eliasis:
WP_Image
Añadir, actualizar y borrar imágenes de posts en WordPress.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/WP_Image
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
WP_Menu
Agregar menú o submenús en WordPress.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/WP_Menu
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
WP_Notice
Mostrar avisos en el panel de administración de WordPress.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/WP_Notice
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
WP_Register
Registrar, minificar y unificar recursos CSS y JavaScript en WordPress.
Para instalar esta biblioteca, simplemente:
composer require Josantonius/WP_Register
Esta biblioteca contiene métodos estáticos y no se implementa en el núcleo de Eliasis.
Developed with Eliasis #volver arriba
Listado de complementos desarrollados con Eliasis Complement:
Módulos
Plugins
Licencia #volver arriba
2017 - 2018 Josantonius.
Código liberado bajo la licencia MIT