• ¡Bienvenido a XenFácil!

    Estás viendo el sitio como Invitado. Para poder participar en este sitio

    y obtendrás privilegios adicionales, acceso a otras áreas y mucho mas.

    ¡Es gratis!


    ¿Ya eres miembro? Inicia sesión
Cómo leer y escribir en la base de datos (con una página)

Tutorial Cómo leer y escribir en la base de datos (con una página)

Para XenForo...
1.2.x
Derechos de autor
Sin indicar
Autor
Fuhrmann
URL de XenForo
http://xenforo.com/community/resources/how-to-read-and-write-into-the-database-with-a-page.328/
Etapa 1 - Crear la tabla.

Para empezar debemos conocer cuáles son los campos que vamos utilizar para leer y/o escribir en la base de datos. Es decir, los campos que almacenarán la información que vamos a querer leer más tarde.

Comenzaremos estableciendo el nombre de la tabla, los campos y los tipos de cada uno:

Nombre de la tabla:
  • xf_simple_text
Nombre de los campos:
  • simple_id -> El campo de incremento automático de cada fila.
  • simple_text -> Este es el campo que contendrá el texto que escribamos. Tipo: varchar; Longitud: 200.
  • simple_date -> Esta es la fecha en que escribimos el texto. Tipo: INT; Longitud: 10.
  • Cada vez que necesitemos crear una tabla en la base de datos, siempre debemos seguir un patrón. Coloquemos el nombre del complemento, junto con el prefijo de las otras tablas de XenForo.
  • Cuanto más precisos seamos definiendo los tipos de cada campo de la tabla, mejor será el rendimiento.


Etapa 2 - Crear el instalador.

Al crear un complemento para XenForo debemos seguir una estructura estándar, tanto en la creación de las carpetas, como con el nombramiento de las clases.

En primer lugar vamos a crear una carpeta para el complemento. Debes estar preguntándote "¿Pero dónde?" Lo haremos dentro de la carpeta DirectorioRaizXenForo/library/.

Este es el esqueleto de la carpeta (tengamos en cuenta que vamos a listar la carpeta XenForo para referencia):
  • DirectorioRaizXenForo
    • library
      • SimpleText -> Carpeta de nuestro complemento.
      • XenForo
Ahora que hemos creado la carpeta, hay que crear un archivo llamado Installer.php que contendrá dos métodos: install() que creará la tabla y uninstall() que eliminará esta tabla, al desinstalar.
  • DirectorioRaizXenForo
    • library
      • SimpleText -> Carpeta de nuestro complemento.
        • Installer.php -> El nuevo archivo.
      • XenForo
Ya tenemos nuestra primera carpeta y archivo en PHP. ¿Pero qué hacemos con esto? Veamos el siguiente paso.

Todos tenemos alguna vez preguntas tontas.
Pregunta. ¿Por qué utilizamos el nombre instalador? ¿Por qué creamos este archivo? ¿Para qué lo utilizaremos?

Respuesta. El archivo Installer.php será el archivo de instalación de nuestro complemento, podemos colocarle el nombre que queramos: "Instalame.php", "MiArchivoDeDeInstalacion.php" o previamente "EsteArchivoNoTieneNombre.php" (no recomendado). Sin embargo, para una mejor comprensión debemos utilizar "Installer.php", por lo que siempre sabremos de qué se trata este archivo.

Cuando creamos un complemento, tenemos la opción de seleccionar una clase para instalar (y método) y una clase para desinstalar (y método). Así que cada vez que alguien instala o desinstala el complemento, serán llamados esta clase y método.

Como este sencillo complemento utiliza una tabla en la base de datos para registrar y leer los datos, vamos a utilizar esta propiedad del complemento para decirle a XenForo que: "XenForo cuando instales mi complemento por favor busca una clase y llama al método SimpleText_Installer::install(), ¿De acuerdo? "


Etapa 3 - El archivo Installer.php.

Dentro del archivo Installer.php tendremos dos funciones: install() y uninstall(). Respectivamente, las dos serán utilizadas para instalar y desinstalar el complemento.
Por lo tanto, abrimos el archivo Installer.php y vamos a empezar a desarrollar creando una clase:
PHP:
<?php
class SimpleText_Installer
{
}
?>
Fijémonos en que hemos utilizado otro patrón que siempre debemos seguir: SimpleText_Installer. ¿Qué quiere decir esto?

Vamos a dar un vistazo a esto entonces:
  • SimpleText -> Es el nombre del directorio.
  • Installer -> Es el nombre del archivo.
Por consiguiente, siempre vamos y debemos seguir este patrón. En cambio si tuviésemos una estructura como esta:
  • library
    • SimpleText -> Carpeta
      • Installer -> Carpeta
        • Installer.php -> Archivo
    • XenForo
Entonces: ¿Cómo sería el nombre de la clase del archivo Installer.php? La respuesta es: SimpleText_Installer_Installer

Veámoslo:
  • SimpleText -> Carpeta
  • Installer -> Carpeta
  • Installer.php -> Archivo
Así que siempre debemos seguir este tipo de estructura. En el siguiente archivo obtendremos más utilización para esto.

Volviendo a nuestro archivo de instalación, ahora vamos a crear una variable que contendrá las definiciones de nuestra tabla, junto con los campos que deseamos crear y los tipos de cada uno. Para ello creamos una variable llamada "$table". Esta variable va a contener un comando SQL CREATE que será el encargado de la creación de la tabla en la base de datos.
PHP:
protected static $table = array(
    'createQuery' => 'CREATE TABLE IF NOT EXISTS `xf_simple_text` (
        `simple_id` INT( 10 ) NOT NULL AUTO_INCREMENT,
        `simple_text` VARCHAR ( 200 ),
        `simple_date` INT( 10 ) UNSIGNED,
        PRIMARY KEY (`simple_id`)
        )
    ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;',
    'dropQuery' => 'DROP TABLE IF EXISTS `xf_simple_text`'
);
Observemos que la variable $table es en realidad una matriz con dos claves:
  • createQuery -> Comando SQL para crear la tabla.
  • dropQuery -> Comando SQL para eliminar la tabla.
Examinemos la clave del comando SQL CreateQuery:

CREATE TABLE IF NOT EXISTS - Crea la tabla si no existe. Si existe, omite este paso y continua con el siguiente (si existe). Para más detalles sobre la condición IF NOT EXISTS.

xf_simple_text - Este es el nombre de la tabla que queremos crear en la base de datos.

`simple_id` INT ( 10 ) - El campo de incremento automático de esta tabla.

`simple_text` VARCHAR ( 200 ) - Primero vamos a crear el campo denominado 'simple_text'. El campo que almacenará el texto que escribamos y que será guardado en la tabla. El tipo es VARCHAR y la longitud es de 200.

`simple_date` INT UNSIGNED ( 10 ) - Este campo almacenará la fecha de envío del texto en la base de datos. Se cambiará cada vez que se escriba un nuevo texto y guardado en la tabla. Es del tipo INT UNSIGNED y la longitud es de 10.

ENGINE = InnoDB - Utilizaremos una tabla Inno DB. Más información.

SET utf8 COLLATE utf8_general_ci - Más información.


Y la clave del comando dropQuery es la siguiente:

DROP TABLE IF EXISTS `xf_simple_text` - Esto eliminará la tabla de la base de datos, si esta existe. Si no, no se hará nada. Más información de DROP TABLE.

Ahora que tenemos nuestras dos consultas para la creación y eliminación de la tabla, crearemos dos funciones que ejecutarán estas dos sentencias SQL.

install()
Este será el método para instalar el complemento, utilizaremos el siguiente código:
PHP:
/**
* Esta es la función para crear la tabla en la base de datos para que el complemento funcione.
*
* @since Version 1.0.0
* @version 1.0.0
* @author Fuhrmann
*/
public static function install()
{
    $db = XenForo_Application::get('db');
    $db->query(self::$table['createQuery']);
}
Explicaciones:
PHP:
$db = XenForo_Application::get('db');
Tomamos el objeto desde la base de datos colocándolo en la variable $db por lo que podemos utilizarlo y llamar a la consulta para crear la tabla.Estamos utilizando la clase XenForo_Application y el método get().
PHP:
$db->query(self::$table['createQuery']);
Utilizamos el objeto db, que es nuestra base de datos, y ejecutamos la consulta 'CreateQuery' que está en la matriz (array) $table, definida anteriormente.

uninstall()
Este será el método para desinstalar el complemento, utilizaremos el siguiente código:
PHP:
/**
* Esta es la función para Eliminar la tabla del complemento en la base de datos.
*
* @since Version 1.0.0
* @version 1.0.0
* @author Fuhrmann
*/
public static function uninstall()
{
    $db = XenForo_Application::get('db');
    $db->query(self::$table['dropQuery']);
}
Como podemos ver, las dos líneas del código son casi iguales a las del método install().

Y este sería el código final:
PHP:
<?php
class SimpleText_Installer
{

    protected static $table = array(
        'createQuery' => 'CREATE TABLE IF NOT EXISTS `xf_simple_text` (
            `simple_id` INT( 10 ) NOT NULL AUTO_INCREMENT,
            `simple_text` VARCHAR ( 200 ),
            `simple_date` INT( 10 ) UNSIGNED ,
            PRIMARY KEY (`simple_id`)
            )
        ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;',
        'dropQuery' => 'DROP TABLE IF EXISTS `xf_simple_text`'
    );

    /**
    * Esta es la función para crear la tabla en la base de datos para que el complemento funcione.
    *
    * @since Version 1.0.0
    * @version 1.0.0
    * @author Fuhrmann
    */
    public static function install()
    {
        $db = XenForo_Application::get('db');
        $db->query(self::$table['createQuery']);
    }

    /**
    * Esta es la función para Eliminar la tabla en la base de datos para que el complemento funcione.
    *
    * @since Version 1.0.0
    * @version 1.0.0
    * @author Fuhrmann
    */
    public static function uninstall()
    {
        $db = XenForo_Application::get('db');
        $db->query(self::$table['dropQuery']);
    }

}
?>
Si no lo recordásemos, las clases de XenForo siguen el patrón de los nombres de las carpetas y archivos. Por consiguiente, la clase XenForo_Application ¿En qué carpeta está?
Intenta adivinar la carpeta y el archivo de las siguientes clases:

Clase-> XenForo_ControllerHelper_CacheRebuild
Carpeta -> ¿¿??
Archivo -> ¿¿??

Clase-> XenForo_DataWriter_Discussion_Thread
Carpeta -> ¿¿??
Archivo -> ¿¿??

Clase-> XenForo_Search_DataHandler_ProfilePost
Carpeta -> ¿¿??
Archivo -> ¿¿??


Etapa 4 - El Modelo.

El modelo es el encargado de leer los datos de nuestra tabla. Una breve explicación:
Modelo (XenForo_Model) - Se utiliza para comunicarse con la base de datos y obtener los datos de ahí. En XenForo esto simplemente proporciona métodos de ayuda para acciones comunes.
Ejemplo: Cuando estamos accediendo a un tema del foro, el modelo es el encargado de traer el contenido del tema, mediante la consulta de la base de datos.
¿¿¿¿???...
Vamos a crear una nueva carpeta y un nuevo archivo dentro de la carpeta del complemento.
DirectorioRaizXenForo
  • library
    • SimpleText
      • Model - Nueva carpeta.
        • SimpleText.php - Nuevo archivo.
      • Installer.php
    • XenForo
Abrimos el archivo Model/SimpleText.php y vamos a darle un nombre a la clase:
PHP:
<?php
class SimpleText_Model_SimpleText extends XenForo_Model
{

}
?>
Como podemos ver seguimos la estructura de la carpeta (SimpleText/Model/SimpleText.php) para nombrar la clase. Como esto es un modelo extendemos la clase XenForo_Model.
Con el archivo abierto vamos a crear un método para obtener una fila en la base de datos:
PHP:
/**
* Obtener una sola fila con los datos pasados.
*/
public function getSimpleTextById($simpleId)
{
    return $this->_getDb()->fetchRow('
        SELECT * FROM xf_simple_text WHERE simple_id = ?', $simpleId);
}
Con esta consulta vamos a seleccionar todos los campos de nuestra tabla donde (WHERE) el campo simple_id es igual al valor pasado a este método.

Ahora el siguiente método obtendrá todas (ALL) las filas.
PHP:
/**
* Obtener todas las filas de la tabla.
*
*/
public function getAllSimpleText()
{
    return $this->fetchAllKeyed('SELECT * FROM xf_simple_text ORDER BY simple_date DESC', 'simple_id');
}
Código Final
PHP:
<?php
class SimpleText_Model_SimpleText extends XenForo_Model
{

    /**
    * Obtener una sola fila con los datos pasados.
    */
    public function getSimpleTextById($simpleId)
    {
        return $this->_getDb()->fetchRow('
            SELECT * FROM xf_simple_text WHERE simple_id = ?', $simpleId);
    }

    /**
    * Obtener todas las filas de la tabla.
    *
    */
    public function getAllSimpleText()
    {
        return $this->fetchAllKeyed('SELECT * FROM xf_simple_text ORDER BY simple_date DESC', 'simple_id');
    }

}
?>
Guardamos el archivo y pasamos a la siguiente etapa.


Etapa 5 - El DataWriter.

El DataWriter será el encargado de escribir los datos en la tabla. Muy a menudo, cuando se desarrolla un complemento, necesitaremos un DataWriter.

Veamos cómo funciona, ¿Qué es un DataWriter?:
DataWriter (XenForo_DataWriter) - Los Datawriters se centran en la escritura de una unidad de datos a la base de datos, incluyendo la verificación de todos los datos a las reglas de la aplicación (incluidas las establecidas por el propietario) y hacer actualizaciones no normalizadas según sea necesario. El Datawriter también puede interactuar con la caché, si fuese requerido.
Así que vamos a crear una nueva carpeta y un nuevo archivo (siempre respetando la estructura estándar)

DirectorioRaizXenForo
  • library
    • SimpleText
      • DataWriter - Nueva carpeta.
        • SimpleText.php - Nuevo archivo.
      • Model
        • SimpleText.php
      • Installer.php
    • XenForo
Por lo tanto, abrimos el archivo SimpleText.php y vamos a darle un nombre a la clase en el archivo:
PHP:
<?php
class SimpleText_DataWriter_SimpleText extends XenForo_DataWriter
{

}
?>
Ahora, tenemos que implementar algunas funciones, las cuales harán que nuestro DataWriter funcione.

1.- protected function _getFields()
Como su nombre indica esta función obtiene todos los campos definidos de la tabla y define algunos tipos. Si añadiésemos nuevos campos a la tabla, necesitaríamos asegurarnos de actualizar este archivo.

El código:
PHP:
/**
* Obtiene los campos definidos para la tabla. Ver los padres para una explicación.
*
* @return array
*/
protected function _getFields() {
    return array(
        'xf_simple_text' => array(
            'simple_id' => array(
                'type' => self::TYPE_UINT,
                'autoIncrement' => true
            ),
            'simple_text' => array(
                'type' => self::TYPE_STRING, 'required' => true
            ),
            'simple_date' => array(
                'type' => self::TYPE_UINT,
                'required' => false,
                'default' => XenForo_Application:$time
            ),
        )
    );
}
2.- protected function _getExistingData($data)
"Gets the actual existing data out of data that was passed in." Así que, cuando utilizamos un DataWriter también podemos actualizar los campos, en lugar de insertar simplemente una nueva fila. Esta función hace seguro que podamos actualizar un registro que ya existe. Graba el contenido del registro existente para que podamos actualizarlo.

El código:
PHP:
/**
* Gets the actual existing data out of data that was passed in. See parent for explanation.
*
* @param mixed
*
* @see XenForo_DataWriter::_getExistingData()
*
* @return array|false
*/
protected function _getExistingData($data)
{
    if (!$id = $this->_getExistingPrimaryKey($data, 'simple_id'))
    {
        return false;
    }

    return array('xf_simple_text' => $this->_getSimpleTextModel()->getSimpleTextById($id));
}
Deberemos tener en cuenta que todavía tenemos una función que no está definida _getSimpleTextModel(). La cual definiremos más adelante. Esta función tomará el modelo (paso 3) y llamará a getSimpleTextById que hemos creado en el paso anterior.

3.- protected function _getUpdateCondition($tableName)
Si quisiéramos actualizar una fila, deberemos tener una condición de actualización.

El código:
PHP:
/**
* Obtiene la condición SQL para actualizar el registro existente.
*
* @see XenForo_DataWriter::_getUpdateCondition()
*
* @return string
*/
protected function _getUpdateCondition($tableName)
{
    return 'simple_id = ' . $this->_db->quote($this->getExisting('simple_id'));
}
Y por último, el método para conseguir el modelo, por lo que podemos utilizarlo dentro de este DataWriter:

El código:
PHP:
/**
* Obtiene el modelo de SimpleText.
*
* @return SimpleText_Model_SimpleText
*/
protected function _getSimpleTextModel()
{
    return $this->getModelFromCache ( 'SimpleText_Model_SimpleText' );
}
¡Hecho! El DataWriter ya está listo:
PHP:
<?php
class SimpleText_DataWriter_SimpleText extends XenForo_DataWriter
{
    /**
    * Obtiene los campos definidos para la tabla. Ver los padres para una explicación.
    *
    * @return array
    */
    protected function _getFields() {
        return array(
            'xf_simple_text' => array(
                'simple_id' => array(
                    'type' => self::TYPE_UINT,
                    'autoIncrement' => true
                ),
                'simple_text' => array(
                    'type' => self::TYPE_STRING, 'required' => true
                ),
                'simple_date' => array(
                    'type' => self::TYPE_UINT,
                    'required' => false,
                    'default' => XenForo_Application:$time
                ),
            )
        );
    }

    /**
    * Gets the actual existing data out of data that was passed in. See parent for explanation.
    *
    * @param mixed
    *
    * @see XenForo_DataWriter::_getExistingData()
    *
    * @return array|false
    */
    protected function _getExistingData($data)
    {
        if (!$id = $this->_getExistingPrimaryKey($data, 'simple_id'))
        {
            return false;
        }

        return array('xf_simple_text' => $this->_getSimpleTextModel()->getSimpleTextById($id));
    }

    /**
    * Obtiene la condición SQL para actualizar el registro existente.
    *
    * @see XenForo_DataWriter::_getUpdateCondition()
    *
    * @return string
    */
    protected function _getUpdateCondition($tableName)
    {
        return 'simple_id = ' . $this->_db->quote($this->getExisting('simple_id'));
    }

    /**
    * Obtiene el modelo de SimpleText.
    *
    * @return SimpleText_Model_SimpleText
    */
    protected function _getSimpleTextModel()
    {
        return $this->getModelFromCache ( 'SimpleText_Model_SimpleText' );
    }

}
?>
.......
  • Me Gusta
Reacciones: raul21 y lms
Autor
luis
Visitas
91
Primer lanzamiento
Última actualización
Votar
5,00 estrella(s) 1 calificaciones

Más recursos de luis

Últimas evaluaciones

Muy bueno.
Arriba