2020-11-16 19:11:10

Modelos de Datos en Anssible Framework

Por @jalexiscv, Hace 2 semanas.
Usando el modelo de CodeIgniter Modelos Acceso a modelos Modelo de CodeIgniter Creando tu modelo Conectarse a la base de datos Configurando su modelo Trabajar con datos Encontrar datos Guardar datos Eliminar datos Validando datos Recuperar reglas de validación Marcadores de posición de validación Protección de campos Trabajar con el generador de consultas Cambios en el tipo de retorno en tiempo de ejecución Procesamiento de grandes cantidades de datos Eventos modelo Definición de devoluciones de llamada Especificar devoluciones de llamada para ejecutar Parámetros de eventos Creación manual de modelos Modelos Los modelos proporcionan una forma de interactuar con una tabla específica en su base de datos. Vienen listos para usar con métodos auxiliares para muchas de las formas estándar en las que necesitaría interactuar con una tabla de base de datos, incluida la búsqueda de registros, la actualización de registros, la eliminación de registros y más. Acceso a modelos Los modelos normalmente se almacenan en el app/Modelsdirectorio. Deben tener un espacio de nombres que coincida con su ubicación dentro del directorio, como .namespace App\Models Puede acceder a los modelos dentro de sus clases creando una nueva instancia o utilizando la model()función auxiliar. // Create a new class manually $userModel = new \App\Models\UserModel(); // Create a new class with the model function $userModel = model('App\Models\UserModel', false); // Create a shared instance of the model $userModel = model('App\Models\UserModel'); // Create shared instance with a supplied database connection // When no namespace is given, it will search through all namespaces // the system knows about and attempt to located the UserModel class. $db = db_connect('custom'); $userModel = model('UserModel', true, $db); Modelo de CodeIgniter CodeIgniter proporciona una clase de modelo que proporciona algunas características interesantes, que incluyen: conexión automática a la base de datos métodos CRUD básicos validación en el modelo paginación automática y más Esta clase proporciona una base sólida desde la cual construir sus propios modelos, lo que le permite construir rápidamente la capa de modelo de su aplicación. Creando tu modelo Para aprovechar el modelo de CodeIgniter, simplemente crearía una nueva clase de modelo que se extienda CodeIgniter\Model: dbse haga a través de la conexión apropiada. find($user_id); El valor se devuelve en el formato especificado en $ returnType. Puede especificar más de una fila para devolver pasando una matriz de valores de primaryKey en lugar de solo uno: $users = $userModel->find([1,2,3]); Si no se pasa ningún parámetro, devolverá todas las filas en la tabla de ese modelo, actuando efectivamente como findAll (), aunque menos explícito. findColumn () Devuelve nulo o una matriz indexada de valores de columna: $user = $userModel->findColumn($column_name); $ column_name debe ser un nombre de una sola columna, de lo contrario obtendrá DataException. encuentra todos() Devuelve todos los resultados: $users = $userModel->findAll(); Esta consulta se puede modificar intercalando comandos del Generador de consultas según sea necesario antes de llamar a este método: $users = $userModel->where('active', 1) ->findAll(); Puede pasar un límite y valores de compensación como el primer y segundo parámetro, respectivamente: $users = $userModel->findAll($limit, $offset); primero() Devuelve la primera fila del conjunto de resultados. Esto se usa mejor en combinación con el generador de consultas. $user = $userModel->where('deleted', 0) ->first(); withDeleted () Si $ useSoftDeletes es verdadero, entonces los métodos find * no devolverán ninguna fila donde 'deleted_at IS NOT NULL'. Para anular esto temporalmente, puede usar el método withDeleted () antes de llamar al método find *. // Only gets non-deleted rows (deleted = 0) $activeUsers = $userModel->findAll(); // Gets all rows $allUsers = $userModel->withDeleted() ->findAll(); onlyDeleted () Mientras que withDeleted () devolverá filas eliminadas y no eliminadas, este método modifica los siguientes métodos de búsqueda * para devolver solo filas eliminadas temporalmente: $deletedUsers = $userModel->onlyDeleted() ->findAll(); Guardar datos insertar() Una matriz asociativa de datos se pasa a este método como el único parámetro para crear una nueva fila de datos en la base de datos. Las claves de la matriz deben coincidir con el nombre de las columnas en una tabla $, mientras que los valores de la matriz son los valores que se guardarán para esa clave: $data = [ 'username' => 'darth', 'email' => 'd.vader@theempire.com' ]; $userModel->insert($data); actualizar() Actualiza un registro existente en la base de datos. El primer parámetro es $ primaryKey del registro a actualizar. Se pasa una matriz asociativa de datos a este método como segundo parámetro. Las claves de la matriz deben coincidir con el nombre de las columnas en una tabla $, mientras que los valores de la matriz son los valores que se guardarán para esa clave: $data = [ 'username' => 'darth', 'email' => 'd.vader@theempire.com' ]; $userModel->update($id, $data); Se pueden actualizar varios registros con una sola llamada pasando una matriz de claves primarias como primer parámetro: $data = [ 'active' => 1 ]; $userModel->update([1, 2, 3], $data); Cuando necesite una solución más flexible, puede dejar los parámetros vacíos y funciona como el comando de actualización del Generador de consultas, con el beneficio adicional de validación, eventos, etc. $userModel ->whereIn('id', [1,2,3]) ->set(['active' => 1]) ->update(); salvar() Este es un contenedor alrededor de los métodos insert () y update () que manejan la inserción o actualización del registro automáticamente, en función de si encuentra una clave de matriz que coincida con el valor $ primaryKey: // Defined as a model property $primaryKey = 'id'; // Does an insert() $data = [ 'username' => 'darth', 'email' => 'd.vader@theempire.com' ]; $userModel->save($data); // Performs an update, since the primary key, 'id', is found. $data = [ 'id' => 3, 'username' => 'darth', 'email' => 'd.vader@theempire.com' ]; $userModel->save($data); The save method also can make working with custom class result objects much simpler by recognizing a non-simple object and grabbing its public and protected values into an array, which is then passed to the appropriate insert or update method. This allows you to work with Entity classes in a very clean way. Entity classes are simple classes that represent a single instance of an object type, like a user, a blog post, job, etc. This class is responsible for maintaining the business logic surrounding the object itself, like formatting elements in a certain way, etc. They shouldn’t have any idea about how they are saved to the database. At their simplest, they might look like this: namespace App\Entities; class Job { protected $id; protected $name; protected $description; public function __get($key) { if (property_exists($this, $key)) { return $this->$key; } } public function __set($key, $value) { if (property_exists($this, $key)) { $this->$key = $value; } } } A very simple model to work with this might look like: use CodeIgniter\Model; class JobModel extends Model { protected $table = 'jobs'; protected $returnType = '\App\Entities\Job'; protected $allowedFields = [ 'name', 'description' ]; } Este modelo funciona con datos de la jobstabla y devuelve todos los resultados como una instancia de App\Entities\Job. Cuando necesite conservar ese registro en la base de datos, deberá escribir métodos personalizados o usar el save()método del modelo para inspeccionar la clase, tomar las propiedades públicas y privadas y guardarlas en la base de datos: // Retrieve a Job instance $job = $model->find(15); // Make some changes $job->name = "Foobar"; // Save the changes $model->save($job); Nota Si trabaja mucho con Entidades, CodeIgniter proporciona una clase de Entidad incorporada que proporciona varias funciones útiles que simplifican el desarrollo de Entidades. Eliminar datos Eliminar() Toma un valor de clave principal como primer parámetro y elimina el registro coincidente de la tabla del modelo: $userModel->delete(12); If the model’s $useSoftDeletes value is true, this will update the row to set deleted_at to the current date and time. You can force a permanent delete by setting the second parameter as true. An array of primary keys can be passed in as the first parameter to delete multiple records at once: $userModel->delete([1,2,3]); If no parameters are passed in, will act like the Query Builder’s delete method, requiring a where call previously: $userModel->where('id', 12)->delete(); purgeDeleted() Cleans out the database table by permanently removing all rows that have ‘deleted_at IS NOT NULL’. $userModel->purgeDeleted(); Validating Data Para muchas personas, validar los datos en el modelo es la forma preferida de garantizar que los datos se mantengan en un solo estándar, sin duplicar el código. La clase de modelo proporciona una manera de tener automáticamente todos los datos validados antes de guardar a la base de datos con los insert(), update()o save()métodos. El primer paso es completar la $validationRulespropiedad de la clase con los campos y reglas que se deben aplicar. Si tiene un mensaje de error personalizado que desea usar, colóquelos en la $validationMessagesmatriz: class UserModel extends Model { protected $validationRules = [ 'username' => 'required|alpha_numeric_space|min_length[3]', 'email' => 'required|valid_email|is_unique[users.email]', 'password' => 'required|min_length[8]', 'pass_confirm' => 'required_with[password]|matches[password]' ]; protected $validationMessages = [ 'email' => [ 'is_unique' => 'Sorry. That email has already been taken. Please choose another.' ] ]; } La otra forma de establecer las reglas de validación en campos por funciones, setValidationRule( $ campo , $ fieldRules ) Parámetros: $ campo ( cadena ) - $ fieldRules ( matriz ) - Esta función establecerá las reglas de validación del campo. Ejemplo de uso: $fieldName = 'username'; $fieldRules = 'required|alpha_numeric_space|min_length[3]'; $model->setValidationRule($fieldName, $fieldRules); setValidationRules( $ validationRules ) Parámetros: $ validationRules ( matriz ) - Esta función establecerá las reglas de validación. Ejemplo de uso: $validationRules = [ 'username' => 'required|alpha_numeric_space|min_length[3]', 'email' => [ 'rules' => 'required|valid_email|is_unique[users.email]', 'errors' => [ 'required' => 'We really need your email.', ], ], ]; $model->setValidationRules($validationRules); La otra forma de configurar el mensaje de validación en campos por funciones, setValidationMessage( $ campo , $ fieldMessages ) Parámetros: $ campo ( cadena ) - $ fieldMessages ( matriz ) - Esta función establecerá los mensajes de error de campo. Ejemplo de uso: $fieldName = 'name'; $fieldValidationMessage = [ 'required' => 'Your name is required here', ]; $model->setValidationMessage($fieldName, $fieldValidationMessage); setValidationMessages( $ fieldMessages ) Parámetros: $ fieldMessages ( matriz ) - Esta función configurará los mensajes de campo. Ejemplo de uso: $fieldValidationMessage = [ 'name' => [ 'required' => 'Your baby name is missing.', 'min_length' => 'Too short, man!', ], ]; $model->setValidationMessages($fieldValidationMessage); Ahora, cada vez que se llama a los insert(), update()o save()métodos, se validarán los datos. Si falla, el modelo devolverá un booleano falso . Puede utilizar el errors()método para recuperar los errores de validación: if ($model->save($data) === false) { return view('updateUser', ['errors' => $model->errors()]); } Esto devuelve una matriz con los nombres de los campos y sus errores asociados que se pueden usar para mostrar todos los errores en la parte superior del formulario o para mostrarlos individualmente:
$error) : ?>

Si prefiere organizar sus reglas y mensajes de error dentro del archivo de configuración de Validación, puede hacerlo y simplemente establecer $validationRulesel nombre del grupo de reglas de validación que creó: class UserModel extends Model { protected $validationRules = 'users'; } Recuperar reglas de validación Puede recuperar las reglas de validación de un modelo accediendo a su validationRules propiedad: $rules = $model->validationRules; You can also retrieve just a subset of those rules by calling the accessor method directly, with options: $rules = $model->getValidationRules($options); The $options parameter is an associative array with one element, whose key is either “except” or “only”, and which has as its value an array of fieldnames of interest.: // get the rules for all but the "username" field $rules = $model->getValidationRules(['except' => ['username']]); // get the rules for only the "city" and "state" fields $rules = $model->getValidationRules(['only' => ['city', 'state']]); Validation Placeholders The model provides a simple method to replace parts of your rules based on data that’s being passed into it. This sounds fairly obscure but can be especially handy with the is_unique validation rule. Placeholders are simply the name of the field (or array key) that was passed in as $data surrounded by curly brackets. It will be replaced by the value of the matched incoming field. An example should clarify this: protected $validationRules = [ 'email' => 'required|valid_email|is_unique[users.email,id,{id}]' ]; In this set of rules, it states that the email address should be unique in the database, except for the row that has an id matching the placeholder’s value. Assuming that the form POST data had the following: $_POST = [ 'id' => 4, 'email' => 'foo@example.com' ]; then the {id} placeholder would be replaced with the number 4, giving this revised rule: protected $validationRules = [ 'email' => 'required|valid_email|is_unique[users.email,id,4]' ]; So it will ignore the row in the database that has id=4 when it verifies the email is unique. This can also be used to create more dynamic rules at runtime, as long as you take care that any dynamic keys passed in don’t conflict with your form data. Protecting Fields To help protect against Mass Assignment Attacks, the Model class requires that you list all of the field names that can be changed during inserts and updates in the $allowedFields class property. Any data provided in addition to these will be removed prior to hitting the database. This is great for ensuring that timestamps, or primary keys do not get changed. protected $allowedFields = ['name', 'email', 'address']; Occasionally, you will find times where you need to be able to change these elements. This is often during testing, migrations, or seeds. In these cases, you can turn the protection on or off: $model->protect(false) ->insert($data) ->protect(true); Working With Query Builder You can get access to a shared instance of the Query Builder for that model’s database connection any time you need it: $builder = $userModel->builder(); This builder is already set up with the model’s $table. You can also use Query Builder methods and the Model’s CRUD methods in the same chained call, allowing for very elegant use: $users = $userModel->where('status', 'active') ->orderBy('last_login', 'asc') ->findAll(); Note You can also access the model’s database connection seamlessly: $user_name = $userModel->escape($name); Runtime Return Type Changes You can specify the format that data should be returned as when using the find*() methods as the class property, $returnType. There may be times that you would like the data back in a different format, though. The Model provides methods that allow you to do just that. Note These methods only change the return type for the next find*() method call. After that, it is reset to its default value. asArray() Returns data from the next find*() method as associative arrays: $users = $userModel->asArray()->where('status', 'active')->findAll(); asObject() Returns data from the next find*() method as standard objects or custom class intances: // Return as standard objects $users = $userModel->asObject()->where('status', 'active')->findAll(); // Return as custom class instances $users = $userModel->asObject('User')->where('status', 'active')->findAll(); Processing Large Amounts of Data Sometimes, you need to process large amounts of data and would run the risk of running out of memory. To make this simpler, you may use the chunk() method to get smaller chunks of data that you can then do your work on. The first parameter is the number of rows to retrieve in a single chunk. The second parameter is a Closure that will be called for each row of data. This is best used during cronjobs, data exports, or other large tasks. $userModel->chunk(100, function ($data) { // do something. // $data is a single row of data. }); Model Events There are several points within the model’s execution that you can specify multiple callback methods to run. These methods can be used to normalize data, hash passwords, save related entities, and much more. The following points in the model’s execution can be affected, each through a class property: $beforeInsert, $afterInsert, $beforeUpdate, afterUpdate, afterFind, and afterDelete. Defining Callbacks You specify the callbacks by first creating a new class method in your model to use. This class will always receive a $data array as its only parameter. The exact contents of the $data array will vary between events, but will always contain a key named data that contains the primary data passed to the original method. In the case of the insert* or update* methods, that will be the key/value pairs that are being inserted into the database. The main array will also contain the other values passed to the method, and be detailed later. The callback method must return the original $data array so other callbacks have the full information. protected function hashPassword(array $data) { if (! isset($data['data']['password']) return $data; $data['data']['password_hash'] = password_hash($data['data']['password'], PASSWORD_DEFAULT); unset($data['data']['password']; return $data; } Specifying Callbacks To Run Usted especifica cuándo ejecutar las devoluciones de llamada agregando el nombre del método a la propiedad de clase apropiada (beforeInsert, afterUpdate, etc.). Se pueden agregar múltiples devoluciones de llamada a un solo evento y se procesarán una tras otra. Puede utilizar la misma devolución de llamada en varios eventos: protected $beforeInsert = ['hashPassword']; protected $beforeUpdate = ['hashPassword']; Además, cada modelo puede permitir (predeterminado) o denegar devoluciones de llamada en toda la clase estableciendo su propiedad $ allowCallbacks: protected $allowCallbacks = false; También puede cambiar esta configuración temporalmente para una sola llamada de modelo cantando el allowCallbacks()método: $model->allowCallbacks(false)->find(1); // No callbacks triggered $model->find(1); // Callbacks subject to original property value Parámetros de eventos Dado que los datos exactos que se pasan a cada devolución de llamada varían un poco, aquí están los detalles sobre lo que hay en el parámetro $ data que se pasa a cada evento: Evento $ contenido de datos antes de insertar datos = los pares clave / valor que se están insertando. Si se pasa un objeto o una clase de entidad al método de inserción, primero se convierte en una matriz. afterInsert id = la clave principal de la nueva fila, o 0 en caso de falla. datos = los pares clave / valor que se insertan. resultado = los resultados del método insert () utilizado a través del Generador de consultas. beforeUpdate id = la clave principal de la fila que se actualiza. datos = los pares clave / valor que se están insertando. Si se pasa un objeto o una clase de entidad al método de inserción, primero se convierte en una matriz. después de la actualización id = la clave principal de la fila que se actualiza. datos = los pares clave / valor que se actualizan. resultado = los resultados del método update () utilizado a través del Generador de consultas. afterFind Varía según el método de búsqueda *. Vea lo siguiente: encontrar() id = la clave principal de la fila que se busca. data = La fila de datos resultante, o nula si no se encuentra ningún resultado. encuentra todos() datos = las filas de datos resultantes, o nulo si no se encuentra ningún resultado. límite = el número de filas para encontrar. offset = el número de filas para omitir durante la búsqueda. primero() datos = la fila resultante encontrada durante la búsqueda, o nula si no se encontró ninguna. beforeDelete Varía según el método de eliminación *. Vea lo siguiente: Eliminar() id = clave principal de la fila que se está eliminando. purge = boolean si las filas de eliminación temporal deben eliminarse por completo. afterDelete Varía según el método de eliminación *. Vea lo siguiente: Eliminar() id = clave principal de la fila que se está eliminando. purge = boolean si las filas de eliminación temporal deben eliminarse por completo. resultado = el resultado de la llamada delete () en el Generador de consultas. datos = no utilizados. Creación manual de modelos No es necesario ampliar ninguna clase especial para crear un modelo para su aplicación. Todo lo que necesita es obtener una instancia de la conexión de la base de datos y estará listo. Esto le permite omitir las funciones que CodeIgniter's Model le brinda de inmediato y crear una experiencia completamente personalizada. db =& $db; } }

Fuente: Jose Alexis Correa Valencia

Notas y referencias

Copyright © 2018 - 2038 Todos los derechos reservados, se prohíbe su reproducción total o parcial, así como su traducción a cualquier idioma sin la autorización escrita de su titular.Términos y condiciones | Políticas de privacidad | Publicidad | Cookies | Más |

XL
LG
MD
SM
XS