Subclases de la Capa de Datos

Para completar nuestra capa de datos, vamos a crear una serie de clases hijas de la clase principal de la que heredan sus métodos y propiedades, las llamadas subclases de la capa de datos.

25-Sep-2016

Para completar nuestra capa de datos, vamos a crear una serie de clases hijas de la clase principal, las llamadas subclases de la capa de datos.

Cada una de estas subclases representará a una tabla y sus vistas correspondientes de la base de datos. Estas clases serán hijas de la clase principal ya que heredarán sus propiedades y métodos, lo que les permitirá añadir nuevas funcionalidades a las ya existentes, dependiendo de las necesidades de la tabla a la que representen.

Cuando necesitemos realizar operaciones con la BD, lo que haremos será crear objetos de cada una de las subclases y los destruiremos una vez hayamos obtenido la información necesaria o hayamos ejecutado los comandos sobre la base de datos.

El procedimiento para trabajar con las clases será:

Crear el objeto de la subclase

Realizar las operaciones necesarias de trabajo

Destruir el objeto una vez hayamos terminado

 

Escenario de trabajo

Para la explicación de esta parte del curso, vamos a definir un escenario de trabajo formado por una base de datos con 3 tablas y 2 vistas.

Supongamos que deseamos diseñar un blog básico en el que publicar artículos y permitir que los usuarios registrados puedan realizar comentarios sobre cada una de las entradas que se vayan publicando.

Base de Datos

En nuestro servidor de pruebas local crearemos una base de datos de nombre ‘Blog’, un usuario con privilegios sobre la bd de nombre ‘admblog’ y con contraseña ‘123456’.

Tablas

tbentradas: entradas publicadas en el blog.

Campo Tipo Comentario
id mediumint autonumérico Clave principal
fecha timestamp
(predeterminado CURRENT_TIMESTAMP)
Fecha de publicación de la entrada
categoria varchar Categoría en la que se agrupa: (Programación, Sistemas, Android, Noticias, etc..)
titulo varchar Título de la entrada
contenido text Contenido de la entrada
bloqueado boolean
(predeterminado 0)
Indicador de publicación de la entrada

tbusuarios: usuarios registrados en el blog y que pueden comentar las entradas publicadas.

Campo Tipo Comentario
id mediumint autonumérico Clave principal
email varchar Email del usuario
clave varchar Clave de acceso
nick varchar Nombre por el que se etiquetarán los comentarios
nombre varchar Nombre completo del usuario
bloqueado boolean
(predeterminado 0)
Indicador de bloqueo para publicar comentarios

tbcomentarios: comentarios realizados por los usuarios sobre las entradas publicadas en el blog.

Campo Tipo Comentario
id mediumint autonumérico Clave principal
id_entrada mediumint Id de la entrada a la que pertenece el comentario (clave foránea de la tabla de entradas)
id_usuario mediumint Id del usuario que publicó el comentario (clave foránea de la tabla de usuarios)
fecha timestamp
(predeterminado CURRENT_TIMESTAMP)
Fecha de publicación del comentario
contenido text Contenido del comentario
bloqueado boolean
(predeterminado 0)
Indicador de bloqueo para mostrar el comentario
valoracion integer Puntuación que da el usuario a la entrada del blog

Vistas

vwentradas_categorias: obtiene las categorías disponibles ordenadas alfabéticamente.

CREATE VIEW vwentradas_categorias AS
SELECT categoria FROM tbentradas 
GROUP BY categoria 
ORDER BY categoria;

vwcomentarios_usuarios: obtiene los comentarios que no están bloqueados con el nick del usuario que lo publicó ordenados por entrada y fecha de publicación.

CREATE VIEW vwcomentarios_usuarios AS
SELECT tbcomentarios.*,tbusuarios.nick 
FROM tbcomentarios INNER JOIN tbusuarios ON tbcomentarios.id_usuario=tbusuarios.id 
WHERE tbcomentarios.bloqueado=FALSE  
ORDER BY tbcomentarios.id_entrada, tbcomentarios.fecha DESC;

Diseño de las subclases

Consideraciones Iniciales

En el apartado ‘Consideraciones’ del primer módulo del curso, os comente los requisitos para los nombres de archivos y las subclases que representan. Es necesario que el nombre de la tabla, el del archivo de la clase y el propio nombre de la clase coincidan de alguna forma y que todos los archivos se encuentren en la misma carpeta.

Teniendo en cuenta estas pequeñas normas los archivos y sus clases quedarían de la siguiente manera:

Tabla Archivo de clase Nombre Clase
tbentradas /clases/class.tbentradas.php TbEntradas
tbusuarios /clases/class.tbusuarios.php TbUsuarios
tbcomentarios /clases/class.tbcomentarios.php TbComentarios

Diseño base

El diseño base para crear una subclase, consiste simplemente en hacer un requerimiento de la clase principal e implementar su constructor.

En el constructor de la clase hija (subclase) se invoca al constructor de la clase principal, indicando el nombre de tabla que se corresponde con el de la propia clase.

El diseño base de la subclase quedaría de la siguiente manera:

<?php
  # Incluimos el requerimiento de la clase principal
  require_once(__DIR__.DIRECTORY_SEPARATOR.'class.cnnmysql.php');
  
  # Definímos la subclase que hereda de la clase principal
  class NombreClase extends CnnMySQL{
     # CONSTRUCTOR DE LA SUBCLASE
     public function __construct() {
     # Llamamos al constructor de la clase principal enviando como argumento el nombre de la clase
     # que tiene que coincidir con el nombre de la tabla o vista de la BD
       parent::__construct(strtolower(__CLASS__));
  }
}

Para cada una de nuestras clases hijas,  simplemente cambiaremos NombreClase por el nombre de la subclase que deseamos crear:

  class TbEntradas extends CnnMySQL{
  …
  }
  class TbUsuarios extends CnnMySQL{
  …
  }
  class TbComentarios extends CnnMySQL{
  …
  }

Con este diseño tan simple ya podemos crear los objetos de acceso a datos que nos permiten ejecutar las sentencias sobre las tablas de la BD.

Cuando necesitemos utilizar alguna subclase, lo primero que haremos será incluir un requerimiento a su archivo de clase, para posteriormente crear el objeto que nos permita acceder a sus propiedades y métodos.

<?php
# Incluimos el requerimiento de la clase, indicando la ruta desde la carpeta raíz de nuestra web 
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'clases'.DIRECTORY_SEPARATOR.'class.tbentradas.php');
# Creamos un objeto de tipo TbEntradas
$Entradas = new TbEntradas();

Veamos un script de ejemplo que maneja la información de los usuarios (ejemplo1.php):

<?php
# Incluimos el requerimiento de la clase 
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'clases'.DIRECTORY_SEPARATOR.'class.tbusuarios.php');
# Creamos un objeto de tipo TbUsuarios
$Usuarios = new TbUsuarios();
# Obtener todas las filas de la tabla de usuarios
$Registros=$Usuarios->select();
# Obtener el total de usuarios bloqueados 
$TotalBloqueados=$Usuarios->count(['Where'=>'bloqueado=true']);
# Obtener tabla HTML con el email y nick de todos los usuarios no bloqueados
$TablaNoBloqueados=$Usuarios->selectHTML(['Where'=>'bloqueado=false', 'Campos'=>'email, nick']);
# Eliminar el usuario con id=100
if($Usuarios->delete(['Where'=>'id=100'])): $MsgEliminar='Usuario con id=100 eliminado.';
else:  $MsgEliminar='Error al eliminar el usuario.';
endif;
# Destruimos el objeto para liberar los recursos una vez que ya no lo necesitamos
unset($Usuarios);
# RESTO DE LINEAS DE LA PÁGINA QUE MOSTRARIAN LA INFORMACIÓN
    …
    …
    …

Podéis observar como en el script anterior gracias a la utilización de la subclase ‘TbUsuarios’, hemos conseguido un código más comprensible, sencillo y reducido que si hubiéramos seguido los métodos tradicionales en los que tenemos que implementar todas las instrucciones de conexión, ejecución y desconexión en el mismo código.

Carga automática de clases

Como ya hemos comentado, cada vez que deseemos crear los objetos de acceso a datos, tendremos que incluir el archivo que contiene la definición de la subclase al principio de nuestro script.

Si queremos ahorrarnos tener escribir la instrucción include o require para cada subclase, podemos crear un script de autocarga que de forma automática vaya cargando estos archivos a medida que vayamos creando los objetos. De esta manera no tendremos que preocuparnos por el archivo que contiene la subclase, simplemente crearemos el objeto y el script de autocarga lo incluirá en nuestro código.

Script de autocarga

Crearemos un script php al que llamaremos autocarga.php y lo guardaremos en la carpeta raíz de nuestra web.

Contenido de nuestro script de autocarga:

<?php
# Definimos constante para hacer referencia al directorio de los archivos de clases
define('DIR_CLASES',$_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'clases'.DIRECTORY_SEPARATOR);
# Loader para la autocarga de las clases
function autocarga_clase($Clase) {
   $FichClass=DIR_CLASES.'class.'.strtolower($Clase). '.php';
   if(file_exists($FichClass)) {
     require_once($FichClass);
   } else { 
     printf("Imposible cargar la clase: <strong>%s</strong> desde el archivo: %s", $Clase, $FichClass); 
     exit(); 
   }
}
# Define el nombre de función de autocarga que se tiene que utilizar a la hora de cargar las clases
spl_autoload_register('autocarga_clase');

Para poder activar la autocarga, tendremos que incluir este archivo al principio de cada script donde vayamos a hacer referencia a nuestras subclases.

<?php
# Requerimos el archivo con el script de autocarga de clases guardado en la raíz de nuestra web
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'autocarga.php');
# Cada vez que creemos un objeto se buscará el archivo necesario y lo incluirá de forma automática
$Usuarios = new TbUsuarios();
$Entradas = new TbEntradas();
    …
    …
    …

A partir de ahora no nos tendremos que preocupar de los archivos de definición de clases, ya que se irán incluyendo de forma automática en nuestros scripts.

Uso combinado de clases

Cuando necesitemos trabajar con la información de varias tablas o vistas de la BD, tendremos que crear objetos para cada una de ellas, creando una combinación de subclases en nuestro código.

Veamos con varios ejemplos como el uso varias subclases simultáneamente también resulta una tarea sencilla gracias a nuestra capa de datos:

Obtener todos los comentarios del usuario con email=’novice@gmail.com’ (ejemplo2.php).

<?php
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'autocarga.php');

# Creamos un objeto de tipo TbUsuarios
$Usuarios = new TbUsuarios();
# Creamos un objeto de tipo TbComentarios
$Comentarios = new TbComentarios();

# Obtener el id del usuario
$email='novice@gmail.com';
$id=$Usuarios->field_value(['Where'=>"email='$email'", 'Campo'=>'id']);
# Obtener todos los comentarios del usuario
$Registros=$Comentarios->select(['Where'=>"id_usuario=$id"]);
# Total de registros obtenidos por la consulta anterior
$total_comentarios=$Comentarios->get_totregistros();
# Destruimos los objetos para liberar los recursos
unset($Usuarios, $Comentarios);

# RESTO DE LINEAS DE LA PÁGINA QUE MOSTRARIAN LA INFORMACIÓN
  …
  …
  …

Bloquear (ocultar) todos los comentarios de las entradas que pertenezcan a la categoría ‘Android’ (ejemplo3.php):

<?php
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'autocarga.php');

# Creamos los objetos necesarios
$Entradas = new TbEntradas();
$Comentarios = new TbComentarios();

# Obtener el id de todas las entradas de la categoría ‘Androdi’
$categoria='Android';
$Registros=$Entradas->select(['Where'=>"categoria='$categoria'", 'Campos'=>'id']);
# Contador de registros bloqueados
$total_comentarios=0;
# Por medio de un array asociativo indicamos como clave el nombre de campo que se tiene que actualizar (bloqueado) y como valor el nuevo valor para el campo (true)
$CamposValores['bloqueado']=true;
# Recorremos el array de entradas obtenidas 
foreach($Registros as $Registro) {
   # Ejecutar la actualización de todos los comentarios pertenecientes a la entrada obtenida
   $Comentarios->update(['CampoValor'=>$CamposValores,'Where'=>'id_entrada='.$Registro['id']]);
   # Actualizamos contador de registros
   $total_comentarios+=$Comentarios->get_totregistros();
}
# Destruimos los objetos para liberar los recursos
unset($Entradas, $Comentarios);

# RESTO DE LINEAS DE LA PÁGINA QUE MOSTRARIAN LA INFORMACIÓN
    …
    …
    …

Ampliar la funcionalidad de las subclases

A partir del diseño inicial que hemos creado, podemos ir añadiendo nuevos métodos a las subclases que aumenten la funcionalidad de nuestra capa de datos.

Para ilustrar como podemos aumentar las prestaciones de la capa de datos, vamos a ir añadiendo una serie de métodos comunes a todas las subclases y otros particulares de cada una.

Comunes a todas las subclases

  • eliminar: eliminar registros a partir de su id (clave principal).
  • nuevo: insertar registros en la tabla a partir de array asociativo (campo => valor) donde la clave representa el nombre del campo y valor el valor a guardar en el campo.
  • actualizar: actualizar filas a partir de un array asociativo (campo => valor) aplicando opcionalmente una condición. Si no se indica condición la actualización se llevará a cabo en todas las filas.
public function eliminar($Id) {
  # Llamamos al método delete enviando la condición
  return parent::delete(['Where'=>"id=$Id"]);
}
public function nuevo($Registro) {
  $args['CampoValor']=$Registro;
  return parent::insert($args);
}
public function actualizar($Campos, $Where=NULL) {
  $args['CampoValor']=$Campos;
  $args['Where']=$Where;
  return parent::update($args);
}

Estos métodos no implican que ya no podamos utilizar los métodos: delete, insert y update de nuestras subclases, sino que lo que pretenden es poder realizar de una forma más sencilla una serie de tareas comunes.

NOTA: para el caso concreto de la clase TbUsuarios el método ‘nuevo’, implica una línea de código adicional que encripte la clave con el algoritmo md5 antes de insertar el registro en la tabla de usuarios, ya que las claves de los usuarios se guardan encriptadas.

 
public function nuevo($Registro) {
  # Encriptamos la clave antes de insertar el registro
  $Registro['clave']=md5($Registro['clave']);
  $args['CampoValor']=$Registro;
  return parent::insert($args);
}...

Nuevos para TbComentarios

  • nobloqueados: obtener todos los comentarios de una entrada no bloqueados incluyendo el Nick del usuario que lo publicó. Podemos obtener las filas indicando el id de la entrada o el id del usuario.
public function nobloqueados($IdEntrada=NULL, $IdUsuario=NULL) {
  $Where=NULL;
  # Establecemos la condición en función de los parámetros
  if(!empty($IdEntrada)) $Where="id_entrada=$IdEntrada"; 
  if(!empty($IdUsuario)) $Where="id_usuario=$IdUsuario";
  # Cambiamos puntualmente el nombre de la tabla por el de la vista
  return parent::select(['Where'=>$Where, 'Tabla'=>'vwcomentarios_usuarios']);   
}

Nuevos para TbUsuarios

  • usuario: obtener la información de un usuario a partir de su id (clave principal).
  • validar: validar a un usuario a partir de su email y clave. Devuelve 0 (email no existe), -1 (clave errónea) o 1 (email y clave correctas).
  • bloquear: bloquear o desbloquear el permiso para editar comentarios de un usuario indicando su id (clave principal) y el estado de bloqueo (false: desbloquear, true u omitido: bloquear).
  • comentarios: obtener todos los comentarios de un usuario a partir de una condición. Este método tiene la particularidad de que su primer argumento es un objeto de la clase TbComentarios que le permitirá ejecutar los métodos de esta clase y el segundo argumento la id del usuario.
public function usuario($Id) {
  $Registros=parent::select(['Where'=>"id=$Id"]); 
  return ($this->get_estado())? $Registros[0]:NULL;
}

public function validar($Email,$Clave) {
  # Buscamos un email que coincida con el argumento $Email
  $valor=parent::field_value(['Campo'=>'email','Where'=>"email='$Email'"]);
  # Si no se ha localizado devuelve 0
  if(empty($valor)) return 0;
  # Buscamos un email que coincida con el argumento $Email y que la clave coincida con el argumento $Clave encriptado con MD5
  $valor=parent::field_value(['Campo'=>'email','Where'=>"email='$Email' AND clave=MD5('$Clave')"]);
  # Si no se ha localizado devuelve -1
  if(empty($valor)) return -1;
  # Si se ha localizado devuelve 1
  return 1;
}

public function bloquear($Id, $Estado=true) {
  # Indicamos el campo a actualizar y su valor
  $CamposValores['bloqueado']=$Estado;
  # Realizamos la actualización del campo para el usuario según su id
  return parent::update(['CampoValor'=>$CamposValores, 'Where'=>"id=$Id"]);
}

public function comentarios($ObjComentarios,$Where){
  # Buscamos el 1er id que cumpla la condición
  $id=parent::field_value(['Campo'=>'id', 'Where'=>$Where]);
  # Llamamos al método nobloqueados del objeto TbComentarios
  $Registros=$ObjComentarios->nobloqueados(NULL,$id);
  # Actualizamos la propiedad TotRegistros del objeto TbUsuarios
  $this->TotRegistros=$ObjComentarios->get_totregistros();
  # Devolvemos el array con los comentarios
  return $Registros;
}

Veamos un pequeño ejemplo con los nuevos métodos añadidos a la clase TbUsuarios (ejemplo4.php):

<?php
# Para la ejecución de este script activaremos el sistema de trazado de la capa de datos, 
# estableciendo a true las configuraciones debug y log del archivo cnn.json
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'autocarga.php');

$Usuarios = new TbUsuarios();
# Obtener los comentarios del usuario con email=’novice@gmail.com’
$email='novice@gmail.com';
$RegComentarios=$Usuarios->comentarios(new TbComentarios, "email='$email'");
# Obtenemos el total de comentarios seleccionados
$total_comentarios=$Usuarios->get_totregistros();
$id=7;
# Obtenemos la información del usuario con id=7
$InfoUsuario[]=$Usuarios->usuario($id);
# Bloqueamos al usuario con id=7 el permiso para publicar comentarios
$Usuarios->bloquear($id);
# Volvemos a leer la información del usuario con id=7
$InfoUsuario[]=$Usuarios->usuario($id);
# Validamos los datos del usuario con email=’novice@gmail.com’ 
$clave=’123456’;
$estado=$Usuarios->validar($email,$clave);
# Destruimos el objeto para liberar los recursos
unset($Usuarios);

# RESTO DE LINEAS DE LA PÁGINA QUE MOSTRARIAN LA INFORMACIÓN
  …
  …
  …

Al finalizar la ejecución si consultamos los registros del archivo cnn.log, podremos ver como se han ido registrando las operaciones que se han llevado a cabo con la BD.

/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0000 :: Solicitud conexión: 1
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0229 :: Conexión abierta.
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0000 :: Solicitud conexión: 2
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0002 :: Utilizando conexión abierta.
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0004 :: SELECT id FROM tbusuarios WHERE (email='novice@gmail.com')
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0005 :: 1 registros seleccionados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: Recurso liberado
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: SELECT * FROM vwcomentarios_usuarios WHERE (id_usuario=1)
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0007 :: 2 registros seleccionados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0004 :: Recurso liberado
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: Cerrando conexión. Solicitudes pendientes: 1
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: SELECT * FROM tbusuarios WHERE (id=3)
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0005 :: 1 registros seleccionados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: Recurso liberado
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: UPDATE tbusuarios SET bloqueado=true WHERE (id=3)
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0039 :: Ejecución Correcta
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: 1 registros afectados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: SELECT * FROM tbusuarios WHERE (id=3)
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0004 :: 1 registros seleccionados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0004 :: Recurso liberado
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: SELECT email FROM tbusuarios WHERE (email='novice@gmail.com')
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0005 :: 1 registros seleccionados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: Recurso liberado
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: SELECT email FROM tbusuarios WHERE (email='novice@gmail.com' AND clave=MD5('123456'))
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0005 :: 1 registros seleccionados
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: Recurso liberado
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0003 :: Cerrando conexión. Solicitudes pendientes: 0
/ejemplos/ejemplo4.php :: 13-10-2016 09:47:53 :: 0.0004 :: Conexión cerrada.

Nuevos para TbEntradas

  • entrada: obtiene la información de una entrada a partir de su id (clave principal).
  • categorias: devuelve una lista de todas las categorías disponibles.
  • comentarios: obtener todos los comentarios de una entrada a partir de su id (clave principal). Este método tiene la particularidad de que su primer argumento es un objeto de la clase TbComentarios que le permitirá ejecutar los métodos de esta clase y el segundo argumento la id de la entrada.
public function entrada($Id) {
  $Registros=parent::select(['Where'=>"id=$Id"]);     
  return ($this->get_estado())? $Registros[0]:NULL;
}

public function categorias() {
  # Cambiamos puntualmente el nombre de la tabla por el de la vista
  return parent::select(['Tabla'=>'vwentradas_categorias']); 
}

public function comentarios($ObjComentarios,$Id){
  $Registros=$ObjComentarios->nobloqueados($Id, NULL);
  $this->TotRegistros=$ObjComentarios->TotRegistros;
  return $Registros;
}

Veamos un pequeño ejemplo con los nuevos métodos añadidos a la clase TbEntradas (ejemplo5.php):

<?php
require_once($_SERVER['DOCUMENT_ROOT'].DIRECTORY_SEPARATOR.'autocarga.php');

# Creamos un objeto de tipo TbEntradas
$Entradas = new TbEntradas();
# Obtener una tabla HTML con todas las filas de la tabla de entradas
$TablaAntes=$Entradas->selectHTML();
# Obtener todos los nombres de las categorías disponibles
$Categorias=$Entradas->categorias();
# Eliminar la entrada con id=7
$id=7;
if($Entradas->eliminar($id)): $MsgEliminar="Entrada con id=$id y todos sus comentarios eliminada.";
else: $MsgEliminar='Error al eliminar la entrada.';
endif;
# Volvemos a obtener una tabla con todas las filas de la tabla de entradas
$TablaDespues=$Entradas->selectHTML();
# Obtenemos todos los comentarios de la entrada con id=1
$RegComentarios=$Entradas->comentarios(new TbComentarios, 1);
# Destruimos el objeto para liberar los recursos una vez que ya no lo necesitamos
unset($Entradas);

# RESTO DE LINEAS DE LA PÁGINA QUE MOSTRARIAN LA INFORMACIÓN
  …
  …
  …

Ejemplos uso de la capa de datos

Junto a la documentación de este módulo se entrega un archivo comprimido con:

  • Base de datos blog (en formato sql para importarla a nuestro servidor local MySQL)
  • Script para crear el usuario con permisos de acceso a la base de datos en formato .sql.
  • Carpeta clases con la clase principal, subclases y archivo de configuraciones.
  • Script de autocarga de clases.
  • Carpeta ejemplos con los ejemplos comentados en este módulo, más 2 ejemplos nuevos:
    • Ejemplo6.php: añadir usuarios, realizar validación de email / clave y listado de usuarios..
    • Ejemplo7.php: mantenimiento de entradas (listar, mostrar, añadir, modificar, eliminar)
    • Ejemplo_listados.php: realizar listados paginados de forma automática.

    En este último ejemplo os añado una nueva clase ‘class.paginacion.php’, que aprovechando las subclases de nuestra capa de datos, nos permite realizar de forma automática listados paginados con ordenación y filtrado utilizando unas simples instrucciones.

 

3 Comentarios

001
avatar
Carmen Gandía
25.09.16 11:08
Módulo muy interesante y detallado de la utilización de clases.
002
avatar
Luis Roca
01.10.16 02:16
Me alegro que te haya gustado
003
avatar
Joel Cosme Salcedo
29.04.17 02:52
Buen trabajo, excelente material