Modelos para control de empleados (employees)¶

1. Introducción¶

En este tema, vamos a crear en completo los modelos para gestionar la información de los empleados de una empresa multinacional. Este sistema debe permitirnos almacenar y manejar varios tipos de datos, como los empleados, sus puestos, salarios, lugares de trabajo, ciudades y países. Cada entidad tiene un conjunto específico de datos asociados que debemos organizar de forma eficiente en la base de datos.

Requisitos del sistema:¶

Empleados: Queremos almacenar la siguiente información sobre los empleados:
- Código: Identificador único del empleado.
- Nombre: Primer nombre del empleado.
- Apellidos: Apellidos del empleado.
- Email: Dirección de correo electrónico del empleado.
- Dirección: Dirección de residencia del empleado.
- Lugar de trabajo: Ubicación física donde el empleado trabaja.
- Puesto: Cargo o función que desempeña el empleado en la empresa.
Puestos: Cada puesto de trabajo debe tener:
- Cargo: Título o nombre del puesto.
- Descripción: Breve descripción de las responsabilidades o funciones del puesto.
Salarios: El sistema debe gestionar los detalles de los salarios, incluyendo:
- Cantidad: El salario base del empleado.
- Paga extra de Junio: Indicación si el empleado recibe una paga extra en junio.
- Paga extra de Diciembre: Indicación si el empleado recibe una paga extra en diciembre.
Lugares de trabajo: Los lugares donde los empleados están asignados deben tener:
- Nombre: Nombre del lugar de trabajo.
- Dirección: Dirección física del lugar de trabajo.
- Código postal: Código postal de la ubicación.
Ciudades: El nombre de las ciudades donde se encuentran los lugares de trabajo.
Países: Los países donde se encuentran las ciudades deben tener:
- Nombre: Nombre del país.
- Código de país: Código único que identifica al país.

El sistema debe permitir una gestión eficiente de esta información, estableciendo relaciones entre las diferentes entidades, como la relación entre un empleado y su puesto, o un lugar de trabajo y un país. El diagrama de entidad-relación (ER) nos ayudará a entender las relaciones entre los diferentes modelos que vamos a crear.

Esquema E.R. (Entidad-Relación)¶

Para los que conozcan BBDD verán que el esquema no es exactamente un ER, pero para los que no lo conozcan es una buena aproximación. De esta manera nos podemos hacer una de los datos y las relaciones entre ellos.

Es siempre una buena práctica comenzar cualquier proyecto de base de datos con un esquema ER para visualizar las entidades y sus relaciones. Ya que luego gran parte de la aplicación (Modelos, Templates, Formularios, rutas, vistas, etc) girarán en torno a este esquema.

erDiagram
    EMPLOYEE {
        string id_number
        string name
        string last_name
        string email
        string address
    }
    JOB {
        string title
        string description
    }
    SALARY {
        int amount
        boolean extra_dec
        boolean extra_jun
    }

    LOCATION {
        string name
    }
    COUNTRY {
        string name
        string country_code
    }

    EMPLOYEE ||--o| JOB: has
    EMPLOYEE ||--o| LOCATION: lives_in
    JOB ||--o| SALARY: has
    LOCATION ||--o| COUNTRY: belongs_to

En este diagrama se aprecian las relaciones:

Un empleado tiene un puesto (relación 1:N).
Un empleado está asignado a un lugar de trabajo (relación 1:N).
Un puesto tiene un salario (relación 1:1).
Un lugar de trabajo pertenece a un país (relación 1:N).

Tipos de relaciones

No es el momento de explicar los diferentes tipos de relaciones y su conectividad, pero para los que ya han trabajado con ellas lo reconocerán. En los siguientes apartados entraremos en detalle sobre cómo implementar este esquema en Django.

2. Creación del Proyecto (company) y la aplicación (employees)¶

Ahora, vamos a crear el proyecto Django y la aplicación employees que se encargará de gestionar todos los datos relacionados con los empleados, puestos, salarios y demás.

2.1 Crear el entorno virtual¶

Primero, vamos a crear un entorno virtual en Python para gestionar las dependencias del proyecto:

# Crear el entorno virtual
python3 -m venv venv

# Activar el entorno virtual
source venv/bin/activate  # Para macOS y Linux

2.2 Instalar Django¶

Con el entorno virtual activado, instala Django:

pip install django

2.3 Crear el proyecto¶

Luego, crea el proyecto company:

django-admin startproject company .

2.4 Crear la aplicación `employees`¶

Crea una nueva aplicación llamada employees que se encargará de gestionar toda la información relacionada con los empleados, puestos, salarios, etc.

python manage.py startapp employees

2.5 Registrar la aplicación en `settings.py`¶

Abre el archivo settings.py en la carpeta company y agrega la aplicación employees a la lista de INSTALLED_APPS:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'employees',  # Aquí añadimos la aplicación employees
]

Recuerda

No lo hemos vuelto a decir, pero recuerda que en caso de ser necesario debes configurar todo lo necesario para que la aplicación funcione, templates, static y si fuera necesario datos de conexión a base de datos. Esta explicado y visto en temas anteriores.

3. Creación de los Modelos a Partir del Esquema ER¶

3.1 Creación de los Modelos Sin Relaciones¶

En este paso, comenzaremos creando los modelos en Django basándonos en el esquema ER que hemos definido previamente. Vamos a crear los modelos correspondientes a empleados, puestos, salarios, lugares de trabajo, países y ciudades.

En el archivo models.py de la aplicación employees, vamos a definir los modelos básicos sin aún establecer las relaciones entre ellos.

Modelos en `employees/models.py`¶

En el script siguiente puedes encontrar la definición inicial de todos los modelos se´gun su descripción.

Faltan Relaciones

El archivo siguiente no está completo, faltan las relaciones entre los modelos. En el siguiente paso las añadiremos y explicaremos. De momento nos centramos en crear los modelos sin relaciones.

employees/models.py
from django.db import models

# Modelo de Puestos
class Job(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()

    def __str__(self):
        return self.title

# Modelo de Salarios
class Salary(models.Model):
    amount = models.IntegerField(default=0)
    extra_dec = models.BooleanField(default=False)
    extra_jun = models.BooleanField(default=False)

# Modelo de Lugares de Trabajo
class Location(models.Model):
    name = models.CharField(max_length=200)
    address = models.CharField(max_length=500)
    postal_code = models.CharField(max_length=20)

# Modelo de Países
class Country(models.Model):
    name = models.CharField(max_length=200)
    country_code = models.CharField(max_length=10)

# Modelo de Empleados
class Employee(models.Model):
    id_number = models.CharField(max_length=100)
    name = models.CharField(max_length=200)
    last_name = models.CharField(max_length=200)
    email = models.EmailField()
    address = models.CharField(max_length=500)

En este paso hemos creado los modelos sin relaciones. Ahora que hemos definido los modelos sin relaciones, en el siguiente paso estableceremos las relaciones necesarias entre ellos.

3.2 Establecimiento de las Relaciones¶

En esta parte, vamos a establecer las relaciones entre los modelos. Para ello, modificaremos los modelos para utilizar ForeignKey (para relaciones 1\:N), OneToOneField (para relaciones 1:1) y ManyToManyField si es necesario. Además, agregaremos las opciones on_delete y related_name para las relaciones.

En este apartado, al añadir las relaciones será impotante seguir un orden a la hora de crear los modelos porque sino al crear las relaciones dará error, sino se ha creado antes la entidad referenciada.

Relación entre Empleado y Puesto¶

Un empleado tiene un único puesto, y cada puesto puede tener muchos empleados. Por lo tanto, crearemos una relación 1\:N entre Empleado y Puesto usando un campo ForeignKey en el modelo Employee.

Relación entre Empleado y Lugar de Trabajo¶

Un empleado está asignado a un único lugar de trabajo, y cada lugar de trabajo puede tener varios empleados. Usamos también un campo ForeignKey para esta relación 1\:N.

Relación entre Puesto y Salario¶

Un puesto tiene un salario específico, y un salario está vinculado a un único puesto. Usamos un campo OneToOneField para esta relación 1:1.

Relación entre Lugar de Trabajo y País¶

Un lugar de trabajo pertenece a un país, y un país puede tener varios lugares de trabajo. Esta es una relación 1\:N, por lo que utilizamos un ForeignKey en el modelo Location.

Modelos en `employees/models.py` con relaciones¶

Importante

Como puedes ver, primero están las relaciones (entidades) que no tiene relaciones y que por tanto no dependen de ninguna otra. Luego las que dependen de otras. Si no se sigue este orden dará error al crear las migraciones.

employees/models.py
from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator

# Modelo de Puestos
class Job(models.Model):
    title = models.CharField(max_length=200, null=False, blank=False)
    description = models.TextField(null=True, blank=True)

    def __str__(self):
        return self.title

# Modelo de Salarios
class Salary(models.Model):
    # Amount debe estar entre 0 y 99999
    amount = models.IntegerField(default=0, 
            validators=[MinValueValidator(0), MaxValueValidator(99999)])
    extra_dec = models.BooleanField(default=False, null=False)
    extra_jun = models.BooleanField(default=False, null=False)

    def __str__(self):
        return f"{self.amount} - Extra Dec: {self.extra_dec} - Extra Jun: {self.extra_jun}"

# Modelo de Lugares de Trabajo
class Location(models.Model):
    name = models.CharField(max_length=200, null=False, blank=False)
    address = models.CharField(max_length=500, null=False, blank=False)
    postal_code = models.CharField(max_length=5, null=False, blank=False)
    country = models.ForeignKey('Country', on_delete=models.CASCADE, related_name='locations')

    def __str__(self):
        return self.name

# Modelo de Países
class Country(models.Model):
    name = models.CharField(max_length=200, null=False, blank=False)
    country_code = models.CharField(max_length=4, null=False, blank=False)

    def __str__(self):
        return self.name

# Modelo de Empleados
class Employee(models.Model):
    id_number = models.CharField(max_length=100, null=False, blank=False)
    name = models.CharField(max_length=200, null=False, blank=False)
    last_name = models.CharField(max_length=200, null=False, blank=False)
    email = models.EmailField(null=False, blank=False)
    address = models.CharField(max_length=500, null=False, blank=False)
    job = models.ForeignKey('Job', on_delete=models.SET_NULL, null=True, related_name='employees')
    location = models.ForeignKey('Location', on_delete=models.SET_NULL, null=True, related_name='employees')

    def __str__(self):
        return f"{self.name} {self.last_name}"

4. Crear las Migraciones y Comprobar que Todo Ha Funcionado Correctamente¶

4.1 Crear las Migraciones¶

Con los modelos definidos, el siguiente paso es crear las migraciones. Las migraciones son los archivos que Django genera para sincronizar las tablas en la base de datos con los modelos definidos en el código.

Ejecuta el siguiente comando para crear las migraciones:

python manage.py makemigrations employees

Esto generará los archivos de migración necesarios para crear las tablas de la base de datos correspondientes a los modelos.

4.2 Aplicar las Migraciones¶

Una vez que se han generado las migraciones, debemos aplicarlas para crear las tablas en la base de datos. Ejecuta el siguiente comando para aplicar las migraciones:

python manage.py migrate

Esto actualizará la base de datos y creará todas las tablas correspondientes a los modelos definidos en el archivo models.py.

4.3 Comprobar que Todo Ha Funcionado Correctamente¶

Utilizar la extensión de sqlite de VSCode o cualquier otro cliente de base de datos para verificar que las tablas se han creado correctamente.

Todas las tablas deben estar creadas.

Si intentamos violar alguna de las restricciones (por ejemplo, insertar un empleado sin un puesto o lugar de trabajo si no se ha permitido null=True), deberíamos recibir un error, lo que confirma que las relaciones y restricciones están funcionando correctamente.

Puedes probar a dar de alta datos de prueba y ver que todo funciona correctamente.

Resumen¶

En este tema, hemos:

Definido los modelos de empleados, puestos, salarios, lugares de trabajo, ciudades y países en Django.
Establecido las relaciones entre ellos utilizando ForeignKey y OneToOneField.
Creado las migraciones necesarias para generar las tablas en la base de datos.
Aplicado las migraciones para actualizar la base de datos y crear las tablas correspondientes.