Home
Doctrine
Doctrine y Codeigniter 3: Definir una entidad
Doctrine, Framework Php Codeigniter

Doctrine y Codeigniter 3: Definir una entidad

2 años ago

Codeigniter

La verdad es que podemos utilizar doctrine no sólo con codeigniter 3, sino con otros frameworks, tales como symfony o zend, así que será fácil de adaptar tanto a una aplicación php que utilice o no utilice un framework.

En este ejemplo vamos a ver cómo definir una entidad sencilla que simule un usuario, crear las anotaciones necesarias para poder crear la tabla a partir de ellas, ejecutar los comandos create, update y drop para actualizar nuestra base de datos con los nuevos cambios y finalmente crear, listar, editar y eliminar registros, así veremos lo sencillo que es empezar a trabajar con Doctrine y Codeigniter 3.

Si tienes dudas para configurar doctrine en Codeigniter 3 sigue este tutorial, al pie del mismo tienes el enlace a mi repo de github para descargar el ejemplo completo.

Doctrine 2, definir una Entidad User

Para definir una entidad User simplemente crea un archivo llamado User.php dentro de models/entities y añade el siguiente código.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
<?php
namespace Entities;
 
/**
* @Entity
* @Table(name="users")
*/
class User
{
    /**
     * @Id @GeneratedValue @Column(type="integer")
     * @var int
     **/
    protected $id;
 
    /**
     * @Column(type="string")
     * @var string
     **/
    protected $username;
 
    /**
     * @Column(type="string")
     * @var string
     **/
    protected $email;
 
    /**
     * @Column(type="string")
     * @var string
     **/
    protected $password;
 
    /**
     * @Column(type="datetime")
     **/
    protected $created;
 
    public function __construct()
    {
        $this->created = new \DateTime("now");
    }
 
    public function getId()
    {
        return $this->id;
    }
 
    public function getUsername()
    {
        return $this->username;
    }
 
    public function setUsername($username)
    {
        $this->username = $username;
    }
 
    public function getEmail()
    {
        return $this->email;
    }
 
    public function setEmail($email)
    {
        $this->email = $email;
    }
 
    public function getPassword()
    {
        return $this->password;
    }
 
    public function setPassword($password)
    {
        $this->password = $password;
    }
 
    public function getCreated()
    {
        return $this->created;
    }
}

Esta es una entidad básica de Doctrine 2, gracias a las anotaciones Doctrine sabrá que debe hacer en cada momento.

  • @Entity: Le dice a Doctrine que es una entidad.

  • @Table(name=”users”): Le dice a Doctrine que debe manejar la entidad con la tabla users

  • @Id @GeneratedValue @Column(type=”integer”): Define una columna primary key y auto increment de tipo integer.

  • @Column(type=”string”): Columna de tipo string.

  • @Column(type=”datetime”): Columna de tipo datetime

Aparte de las anotaciones, tenemos todos los setters y getters necesarios para poder acceder y así establecer las propiedades de nuestra entidad, aparte de esto, debe quedar claro que las propiedades de una entidad deben ser definidas como protected o private.

Dicho todo lo anterior, asegúrate de tener correctamente configurada la conexión con tu base de datos y ejecuta el siguiente comando en la raíz de tu proyecto para crear la tabla users a partir de la entidad User.

Shell
1
vendor\bin\doctrine orm:schema-tool:create

Si todo ha ido bien, verás un mensaje diciendo: Database schema created successfully!, si revisas tu base de datos podrás ver que la tabla users ha sido creada correctamente, el sql generado de ese proceso es el siguiente.

PgSQL
1
2
3
4
5
6
7
8
CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `email` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `password` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
  `created` datetime NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

Si por algún motivo decides tirar hacia atrás ese proceso simplemente ejecuta el siguiente comando.

Shell
1
vendor\bin\doctrine orm:schema-tool:drop --force

Ese proceso habrá eliminado nuestra tabla users, para volver a crearla puedes optar por el método create o update.

Shell
1
vendor\bin\doctrine orm:schema-tool:create

Shell
1
vendor\bin\doctrine orm:schema-tool:update --force

Crear usuarios con Doctrine y Codeigniter 3

Crea un controlador y añade el siguiente método para poder guardar usuarios en la tabla users.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* @desc Crea un usuario con doctrine
*/
public function create()
{
    //creamos una instancia de la entidad User
    $user = new Entities\User;
    
    //establecemos las propiedades a través de los setters
    $user->setUsername("pepe");
    $user->setEmail("[email protected]");
    $user->setPassword("123456");
 
    //guardamos la entidad en la tabla users
    $this->doctrine->em->persist($user);
    $this->doctrine->em->flush();
    echo "Se ha creado el usuario con ID " . $user->getId() . "\n";
}

Obtener usuarios con Doctrine y Codeigniter 3

Ahora añade el siguiente método para poder mostrar todos los usuarios de la tabla users.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
* @desc Obtiene y lista a todos los usuarios
*/
public function index()
{
    //obtenemos y mostramos todos los usuarios con el método findAll disponible en todo repositorio
    $users = $this->doctrine->em->getRepository("Entities\\User")->findAll();
    if( ! empty($users))
    {
        foreach ($users as $user)
        {
            echo sprintf(
                "- %s, %s, %s, %s <br>",
                $user->getUsername(), $user->getPassword(), $user->getEmail(), $user->getCreated()->format("d/m/Y")
            );
        }
    }
    else
    {
        echo "No hay usuarios";
    }
}

Obtener un usuario con Doctrine y Codeigniter 3

Ahora añade el siguiente método para poder mostrar un usuario de la tabla users por su id.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* @param $id
* @desc Obtiene un usuario por su id
*/
public function find($id)
{
    //obtiene un usuario con el método find de otra forma.
    $user = $this->doctrine->em->find("Entities\\User", $id);
    if ($user === null)
    {
        echo "No existe el usuario.\n";
        exit();
    }
 
    echo sprintf(
        "- %s, %s, %s, %s <br>",
        $user->getUsername(), $user->getPassword(), $user->getEmail(), $user->getCreated()->format("d/m/Y")
    );
}

Actualizar un usuario con Doctrine y Codeigniter 3

Ahora vamos a actualizar el nombre de un usuario, para ello simplemente añade el siguiente método a tu controlador.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* @param $id
* @param $username
* @desc Actualiza un usuario
*/
public function update($id, $username)
{
    //obtenemos el usuario
    $user = $this->doctrine->em->getRepository("Entities\\User")->find($id);
 
    if ($user === null)
    {
        echo "No existe el usuario.\n";
        exit();
    }
 
    //seteamos su nombre y lo actualizamos
    $user->setUsername($username);
    $this->doctrine->em->flush();
 
    echo "<pre>";
    print_r($user);
}

Eliminar un usuario con Doctrine y Codeigniter 3

Ahora vamos a eliminar un usuario, para ello simplemente añade el siguiente método a tu controlador.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* @param $id
* @desc Obtenemos un usuario por su id con el método findOneBy por su id y si existe lo eliminamos
*/
public function remove($id)
{
    $user = $this->doctrine->em->getRepository("Entities\\User")->findOneBy(["id" => $id]);
    if ($user === null)
    {
        echo "No existe el usuario.\n";
        exit();
    }
    $this->doctrine->em->remove($user);
    $this->doctrine->em->flush();
}

Y eso es todo, llegados aquí ya hemos hecho todas las operaciones básicas con nuestra entidad utilizando Doctrine y Codeigniter 3.

Posts relacionados

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. ACEPTAR

Aviso de cookies
No te pierdas los últimos cursos y las nuevas promociones de CursosdesarrollowebACCEDER AHORA
+ +