Ciro
Incremental Changes.
Ciro es un marco MVC PHP para iniciar proyectos rápidamente, está diseñado para ser simple, configurable, modular, desacoplado, extensible y liviano para facilitar el código PHP mejor y fácil de mantener.
Fuera de la caja Ciro viene con:
Ciro viene con un proyecto de plantilla con un sistema de autenticación simple para iniciar el desarrollo para su proyecto o prototipo.
Ejemplo en línea del Proyecto de plantilla de marco: https://ciro-framework.herokuapp.com
C:xampphtdocs para Windows o /Applications/XAMPP/xamppfiles/htdocs para Mac.httpd.conf de XAMPP en el directorio de CIRO, consulte Instrucciones: Aquí.Para usar el inicio de sesión/registro prefabricado, y está utilizando SQL (no Mongo) debe crear la base de datos y las tablas en SQL.
http://localhost/phpmyadmin y ejecute la consulta en sql_database_script.sql que existe en el directorio raíz. Para usar el inicio de sesión/registro prefabricado, y desea utilizar MongoDB, debe instalar mongodb extension y MongoDB PHP Library utilizando el compositor, instrucciones aquí. También reemplace Models/UserRepository.php con Models.disabled.mongo.userrepository.class.php para usar la versión MongoDB.
Mysqli para MySQL.PDO para PDO compatible con RDBMS.MongoDB (PHP 7.0+).Todo configurable a través de los archivos de configuración.
La estructura del proyecto sigue las especificaciones de PSR-4 compatibles con los nombres.
+---Config <- Contains Configurations Files.
+---Controllers <- Contains a Dir for each Route each contains this Route's Controllers.
+---Core <- Contains Core Classes for the framework
+---Logs <- Contains Logs created by the scripts (e.g Exception Handler logs)
+---Models <- Contains Models (can be sub-directoried using namespaces using PSR-4 specs.
+---Utilities <- Contains Utility Classes.
+---Vendor <- Composer's Vendor Dir, contains autoloader code and third-party packeges.
+---Views <- Contains Views, a Dir for each route, each contains a Dir for each Controller.
| +---_FullMessages <- Contains Full Messages HTML designs.
| +---_Layouts <- Contains Layouts
+---Webroot <- Public Dir contains the single point of entry of the program, and all public assets.
En CIRO, una ruta URL predeterminada tiene la siguiente estructura:
http://example.io/{route}/{controller}/{action}/{param1?}/{param2?}/...
Esta URL se resuelve con el método {action} del controlador {controller} en el espacio de nombres controllers/{route} por lo que en la notación PHP OOP corresponde a:
App Controllers { route }{controller} -> { action } En la configuración Config/config.php , puede especificar un 'default_route' para que si una URL no contiene una ruta, el programa enrutará de acuerdo con la ruta predeterminada. Por defecto, el 'default_route' es 'web'. Por lo tanto, una URL típica que usa la ruta predeterminada tendrá la siguiente estructura:
http://example.io/{controller}/{action}/{param1?}/{param2?}/...
Entonces, en PHP, la notación OOP corresponde a:
App Controllers Web {controller} -> { action }Otro ejemplo:
for $id
http://example.io/{controller}/{action}/{param1}
http://example.io/ Product / View / 6800
Si la URL no especifica {action} , el programa para enrutar a 'default_action' especificado en 'config/config.php'.
Si la URL no especifica {controller} , el programa se enruta al 'default_controller' especificado en 'config/config.php'.
Para agregar una nueva ruta y acceder a ella utilizando el enrutamiento predeterminado, debe agregarla en la tabla de enrutamiento Config/config.php .
Dada esta URL, por ejemplo:
for $id $color
http://example.io/{controller}/{action}/{param1}/{param2}
http://example.io/ Product / View / 6800 / red
Los parámetros son accesibles dentro del método del controlador a través de $this -> params[0..*] matriz, por ejemplo $this->params[0] contiene el valor de {param1} en la URL anterior.
Otra forma de acceder a los parámetros dentro del método del controlador es agregar argumentos al método del controlador en sí. Usando el mismo ejemplo anterior, si ProductController -> View se define así:
class ProductController extends WebController {
public function view ( $ id , $ color = ' white ' ){
/* controller's method code here */
}
} $id tendrá el valor de {param1} , $color tendrá el valor de {param2} y así sucesivamente ...
Observe que si {param2} no estaba en la URL, $color usará el valor predeterminado especificado, sin embargo, si {param1} no estaba en la URL, el programa representará un mensaje 404: Not Found porque $id no tiene un valor predeterminado especificado en el método del controlador.
Las rutas personalizadas le brindan la posibilidad de especificar una URL con un patrón específico de que, si se combina, la URL se enruta a la {route}{controller}::{action} especificada con los parámetros especificados adecuados.
Las rutas personalizadas se pueden habilitar/deshabilitar en Config/config.php .
Puede especificar una ruta personalizada para cada verbo HTTP REST EG ( GET, POST, PUT, DELETE, etc ) o especificar una ruta personalizada para todos los verbos HTTP posibles usando:
// for GET requests
Route:: get ( $ uri , $ route , $ controller , $ action );
// same for POST, PUT, DELETE, etc requests
Route:: post (), Route:: put (), Route:: delete (), Route:: patch (), Route:: options ();
// for ALL requests
Route:: all ();Las rutas personalizadas se definen en /config/routes.php .
Route:: get ( ' custom/route/{id}/{name}/{language?} ' , ' Web ' , ' Home ' , ' CustomRouteAction ' ); Cualquier URL que coincida con custom/route/{id}/{name}/{language?} Se enrutará a: Route: Web Controller: Home Action: CustomRouteAction .
{ name } , los parámetros opcionales deberían tener un '?' Al final de sus nombres { optinoalParam? } .$this -> params[0..*] matriz y se ordenan respectivamente al orden de ellos en la URL.$this -> param[0] corresponde a {id} , $this -> param[1] corresponde a {name} , etc.El método de un controlador de una ruta personalizada debe definirse de la siguiente manera:
class HomeController extends WebController {
public function CustomRouteAction ( $ id , $ name , $ language = ' default ' ){
/* controller's method code here */
}
} Nota En el ejemplo anterior: {language?} Es un parámetro opcional, los parámetros opcionales deberían tener un '?' Al final de sus nombres, y debe tener un valor predeterminado en el método del controlador, de lo contrario, si falta el parámetro, el programa representará un mensaje 404: Not Found porque no se dio un parámetro opcional y no tiene valor predeterminado.
Al establecer una ruta personalizada, puede colocar un parámetro variable en la route de destino, controller o action para crear una ruta personalizada más 'general'.
Ejemplo:
Route:: get ( ' custom/{var_controller}/pattern/{action}/{param1} ' , ' Web ' , ' {var_controller} ' , ' {action} ' ); Cualquier URL que coincida con custom/{var_controller}/pattern/{action}/{param1}
se enrutará a: ruta: Web , controlador: {var_controller} , Action: {action} y Params no incluirá ni {var_controller} ni {action} porque se usaron en el enrutamiento.
Entonces, si una solicitud con URL = Custom / Account / Pattern / View / sherifabdlnaby vino, se enrutará a: Ruta: Web , Controlador: Account , Acción: View y Params [0] = ' sherifabdlnaby '
El controlador es responsable de procesar las solicitudes de los usuarios y devolver la salida para el usuario, ya sea como HTML para WebControllers , o JSONRESULT para ApiControllers , o redirige a otro destino.
El directorio de controladores debe coincidir con el espacio de nombres del controlador y debe ser el siguiente Controllers{route}{ControllerName}Controller.php y usando la AppControllers{route} donde {route} es la ruta donde pertenece este controlador.
+---Controllers
| +---Api <-- Api route dir.
| | HomeController.php <-- Home Controller for API route.
| |
| ---Web <-- Web (Default) route dir.
| AccountController.php
| HomeController.php <-- Home Controller for Web default route.
Un controlador tiene 4 variables protegidas que utiliza:
$ params ; // array() that holds method's params
$ model ; // controller's model
$ data ; // the $data array() is what is passed to the controller's view.
$ meta ; // the $meta array() is what is passed to $layout meta section (for WebControllers Only)La salida de un controlador (y lo que ve el usuario) es lo que se devuelve a través de él.
Los controladores en CIRO tienen varias funciones que usar al devolver la salida dentro de los controladores para aliviar estas tareas.
Render renderizará una página web HTML usando un diseño, un diseño contiene encabezado, sección de metadatos, alertas, cuerpo y pie de página. La sección del cuerpo del diseño se determina de acuerdo con la visión del método del controlador.
La vista del controlador utiliza la matriz $ datos [] para representar sus elementos, y la sección de metadatos usa la matriz $ meta [].
render ( $ layout = null , $ viewPath = null , & $ data = null , & $ meta = null );| Argumento | Descripción | Valor predeterminado |
|---|---|---|
$layout | Especifica el diseño de la vista utilizado para renderizar | Diseño predeterminado especificado en config.php |
$viewPath | Especifica la ruta para la vista | Ver determinado de acuerdo con el nombre del método del controlador |
$data | La vista $data Array () también tendrá acceso | La propia matriz $data del controlador () |
$meta | El diseño $meta matriz () también tendrá acceso | La propia matriz $meta del controlador () |
devolver $this->render(); Sin ningún argumento dado (usando valores predeterminados) será suficiente en el 90% de los casos.
Uso básico de $ this -> render ();
class AccountController extends WebController {
public function View ( $ username ){
$ this -> data [ ' name ' ] = $ username ;
return $ this -> render ();
}
}RenderFullRor y RenderfullMessage hará una página de mensaje/error personalizado. Si se proporciona un código de estado en el segundo parámetro, el controlador envía el encabezado del código de estado HTTP correspondiente y representa la vista de este código.
function renderFullError( $ message , $ statusCode = null , $ layout = null );
function renderFullMessage( $ message , $ statusCode = null , $ layout = null );| Argumento | Descripción | Valor predeterminado |
|---|---|---|
$message | Un mensaje que se realizará en la vista. | Ninguno (campo requerido) |
$statusCode | Código de estado HTTP | nulo |
$layout | Especifica el diseño de la vista utilizado para renderizar | Diseño predeterminado especificado en config.php |
Uso básico de $ this -> renderfulLerror () / renderfullMessage ();
class AccountController extends WebController {
public function View ( $ username ){
if ( /* User Found */ )
return $ this -> render ();
else
return $ this -> renderFullError ( ' User not found! ' , 404 );
}
}Si se planteó alguna excepción durante la ejecución del script, el marco hará una página de error de error de error de servidor interno 500.
Al devolver $ this -> return () desde la salida de un controlador se envía al usuario, pero el usuario se redirige a la URL dada.
function redirect( $ path );| Argumento | Descripción | Valor predeterminado |
|---|---|---|
| $ | Un camino Relative o Full para ser redirigido a | Ninguno (campo requerido) |
Uso básico de $ this -> redirect ();
class AccountController extends WebController {
public function Login ( $ username , $ password ){
if ( /* Login Success */ )
return $ this -> redirect ( ' / ' ); // redirect to homepage.
else
return $ this -> renderFullMessage ( ' Incorrect Username or Password ' , 401 );
}
}Compruebe si el usuario está/no inicia sesión, redirige a la página de inicio/inicio de sesión si no.
Estado no utilizan estas funciones por declaración de retorno, sin embargo, detiene el script si están redirigiendo al usuario, lo que significa que cualquier código debajo de estas funciones no se ejecutará si su validación es falsa;
function verifyLoggedIn();
function verifyNotLoggedIn();Uso básico de $ this -> verifyLoggedIn () / verifyNotLoggedIn ();
class AccountController extends WebController {
public function Login ( $ username , $ password ){
$ this -> verifyNotLoggedIn (); //Redirects to Homepage if user is already logged in.
if ( /* Login Success */ )
return $ this -> redirect ( ' / ' );
else
return $ this -> renderFullMessage ( ' Incorrect Username or Password ' , 401 );
}
} La clase de sesión es una clase extensible que administrará el uso de $ _ SESSION en los programas para hacer cumplir el principio de responsabilidad única.
/* Save Parameters to $_SESSION, use for Login */
public static function saveLoginSession( $ _id , $ username );
/* Return TRUE if user is logged On */
public static function isLoggedIn ();
/* Unset and Destroy current Session, use for logout */
public static function destroyLoginSession ();
/* Add Error Alerts to be rendered to user when controller's $this -> render() is called */
public static function addErrorAlert ( $ errorAlert );
/* Add Warning Alerts to be rendered to user when controller's $this -> render() is called */
public static function addWarningAlert ( $ warningAlert );
/* Add info Alerts to be rendered to user when controller's $this -> render() is called */
public static function addInfoAlert ( $ infoAlert );
/* Add success Alerts to be rendered to user when controller's $this -> render() is called */
public static function addSuccessAlert ( $ successAlert );Las alertas son mensajes flash guardados en las sesiones del usuario, las alertas se pueden mostrar al usuario, ya sea representando como un HTML o codificándolas en JSON en el caso de una API.
Las alertas se pueden usar para mostrar errores sobre la validación de la forma, o un mensaje si un proceso tuvo éxito o fallado.
Las alertas tienen su propia sección en cualquier diseño, la función de controlador -> render () representará cualquier alerta almacenada en la sesión de usuario.
Hay 4 tipos de alertas:
Un diseño es la estructura de la página web HTML, consta de 5 secciones
| Sección | Descripción |
|---|---|
| meta | Esta sección representa etiquetas de metadatos HTML para etiquetas de título, DESC y SEO. Los metadatos aprobados y llenos por el controlador y es accesible en la matriz $ meta () |
| encabezamiento | Esta sección presenta el encabezado de la página |
| alertas | Esta sección presenta alertas almacenadas en la sesión del usuario si hay alguna |
| contenido | Esta sección presenta la parte principal de la página y hace que sus datos sean aprobados y llenados por el controlador |
| pie de página | Esta sección representa el pie de página de la página |
+---Views
| ---_Layouts
| ---default <-- Layout root directory.
| | | footer.html
| | | header.html
| | | layout.html
| | | meta.html
| | ---alerts <-- alerts directory.
| | errors.html
| | infos.html
| | successes.html
| | warnings.html
| ---anotherLayout
Layout.html es el archivo final reproducido al representar el diseño, es la estructura de la cual va sobre la cual, etc. y cualquier CSS/JS que se use en este diseño debe incluirse en el diseño.html, como Bootstrap CSS y JS
<!DOCTYPE html >
< html lang =" en " >
< head >
< ?= $data['meta'] ? >
< link rel =" stylesheet " href =" /bootstrap/css/bootstrap.min.css " >
</ head >
< body >
< ?= $data['header'] ? >
< ?= $data['alerts'] ? >
< ?= $data['content'] ? >
< ?= $data['footer'] ? >
< script src =" /bootstrap/js/bootstrap.min.js " > </ script >
</ body >
</ html > 
Una vista es la salida de la acción de un controlador web, una vista tiene una matriz de Data Assoc que es aprobada por el controlador, se utiliza para pasar datos entre el controlador y la vista. La ubicación de la vista debe coincidir con la ruta del controlador/estructura del espacio de nombres.
View de acción del Account Controller en la ruta Web +---Controllers
| +---Api
| | HomeController.php
| |
| ---Web
| AccountController.php <-- Account Controller of Web route in ControllersWeb
| HomeController.php
|
+---Views
| +---Web
| | +---Account <-- Account Controller View Dir in ControllerWebAccount
| | | Index.html
| | | Login.html
| | | Register.html
| | | View.html <-- The View for action 'View', of 'Account Controller' in the 'Web' Route
| | |
| | ---Home
| | About.html
| | Index.html
Config/config.php .Las clases de ayuda de la base de datos se utilizan para obtener una instancia de Singleton para conexiones de bases de datos, donde las credenciales de conexión se almacenan en archivos de configuración.
| Clase | Extensión | Descripción |
|---|---|---|
| Dbpdo | PDO | Una clase Singleton para la extensión PDO DB, PDO se puede usar para conectarse a varios RDBM como MySQL, Mariadb o PostgreSQL, credenciales de conexión establecidas en Configpdo.php y habilitado en Config/config.php |
| Dbsql | Mysqli | Una clase Singleton para MySQLI Extension, credenciales de conexión para MySQL establecido en Configmysqli.php y habilitado en Config/config.php |
| Dbmongo | mongodb usando MongoDB PHP Library (PHP 7.0+) | Una clase Singleton para una conexión de la biblioteca MongoDB PHP que se construye alrededor de la extensión mongodb de bajo nivel, las credenciales se almacenan en Configmongo.php y habilitadas en Config/config.php |
mongodb y MongoDB PHP Library , que requiere PHP 7.0+ composer require mongodb/mongodbCiro PHP Framework está bajo la licencia MIT, puede ver la licencia aquí.
