Netflix Clone

Este proyecto es un clon de Netflix, una plataforma de transmisión de contenido multimedia. El objetivo de este proyecto es recrear la funcionalidad básica de Netflix, permitiendo a los usuarios registrarse, iniciar sesión, ver películas y series, y gestionar sus perfiles.

    Stack Tecnológico

El stack tecnológico utilizado en esta plataforma de Netflix clone es el siguiente:

Front-end:
- HTML/CSS/JavaScript
- Bootstrap
- Django templates

Back-end:
- Python
- Django
- SQLite

También se pueden considerar algunas alternativas para el stack tecnológico:

Front-end:
- Vue.js
- Angular
- Ember.js

Back-end:
- Ruby on Rails
- Express.js
- Laravel

     Esquema de la Base de Datos

La base de datos se puede representar con los siguientes ejemplos de tablas: "core_category", "core_movie" y "core_series".

La tabla "core_category" tiene los siguientes campos: "id" (clave primaria), "name", "description" y "slug".

La tabla "core_movie" tiene los siguientes campos: "id" (clave primaria), "title", "description", "created", "uuid", "type", "flyer", "age_limit", "duration", "cover_image", "category_id" y "slug". La columna "category_id" es una referencia a la tabla "core_category".

La tabla "core_series" tiene los siguientes campos: "id", "title", "num_seasons", "num_episodes", "episode_duration", "description", "created", "uuid", "type", "flyer", "age_limit", "cover_image", "category_id" y "videos". La columna "category_id" es una referencia a la tabla "core_category".

Esquema:

Tabla "core_category":
- id (int, clave primaria)
- name (varchar(100), no nulo)
- description (texto)
- slug (varchar(50), no nulo, único)

Tabla "core_movie":
- id (int, clave primaria)
- title (varchar(225), no nulo)
- description (texto, no nulo)
- created (datetime, no nulo)
- uuid (char(32), no nulo, único)
- type (varchar(15), no nulo)
- flyer (varchar(100))
- age_limit (varchar(5))
- duration (int sin signo, no nulo)
- cover_image (varchar(100), no nulo)
- category_id (int, referencia a "core_category"."id" en caso de existir)
- slug (varchar(50), no nulo, único)

Tabla "core_series":
- id (int)
- title (varchar(200), no nulo)
- num_seasons (int, no nulo, por defecto 3)
- num_episodes (int, no nulo, por defecto 8)
- episode_duration (int, no nulo, por defecto 60)
- description (texto, no nulo)
- created (datetime, no nulo)
- uuid (UUID, no nulo, único)
- type (varchar(10), no nulo)
- flyer (varchar(100))
- age_limit (varchar(5))
- cover_image (varchar(100))
- category_id (int, referencia a "core_category"."id" en caso de existir)

La clase Movie es un modelo de Django que representa una película. Tiene varios campos, incluyendo el título, la descripción, la fecha de creación, el identificador único (UUID), el tipo de película (película o serie), la calificación de edad, la duración, la imagen de portada y la categoría. La categoría es una clave externa que se relaciona con la clase Categoría, que también está definida en el modelo.

La aplicación tiene como objetivo proporcionar una experiencia web práctica y fácil de usar, centrándose en la simplicidad, la claridad y la intuición.

Para garantizar que los niños tengan acceso solo a contenido apropiado para su edad, la plataforma incluye un sistema de control parental que restringe el acceso a ciertos contenidos. Para acceder al contenido infantil, los usuarios deben activar la opción "Niños" en la interfaz de usuario. Cuando está activado, solo se mostrará el contenido etiquetado como apto para niños y se restringirá el acceso al contenido que no cumpla con esta clasificación. El sistema de control parental se implementa en la base de datos a través del campo "age_limit" en las tablas de películas y series. Al crear contenido nuevo, se especifica la edad mínima recomendada para ese contenido. Si la edad del usuario es inferior a la edad mínima, el contenido no estará disponible para ese usuario. Además, los padres o tutores deben establecer una contraseña de control parental para desbloquear el acceso a contenido restringido. Esta contraseña se almacena de forma segura en la base de datos y se requiere para desbloquear el acceso a contenido restringido.

La vista ProfileCreate maneja las solicitudes GET y POST para crear un nuevo perfil asociado con el usuario autenticado. Utiliza un ProfileForm para validar la entrada del usuario y crear el perfil en la base de datos. Si el formulario es válido, se redirige al usuario a la página de visualización de películas para el perfil recién creado. Si el formulario no es válido, se muestra el formulario con los errores correspondientes.

Para obtener los datos necesarios y generar los gráficos correspondientes, se ha implementado la función analytics_view(). Utiliza la función compute_total_duration() para recuperar los datos y la biblioteca Plotly para generar el gráfico con formato HTML que se muestra en la plantilla. Además, se implementó la vista admin_analytics(), que muestra los mismos gráficos para el administrador y les permite comparar los datos de los usuarios.

Matplotlib se ha utilizado en este proyecto para generar gráficos que indican el tiempo total que los usuarios han dedicado a ver películas y series. Para ello se ha creado un módulo denominado analytics.py, que contiene tres funciones principales:

get_watched_data(): recupera datos de películas y series vistas por los usuarios de la base de datos y los almacena en un marco de datos de pandas.
calcule_total_duration(): En base a los datos obtenidos en la función anterior, calcula la duración total de las películas y series vistas por cada usuario.
plot_total_duration(): Crea un gráfico de barras utilizando los datos obtenidos en la función anterior.

En resumen, el uso de Matplotlib en el proyecto permite generar gráficos claros y directos que visualizan la duración total de las películas y series vistas por los usuarios. Estos gráficos son de gran utilidad para el análisis de datos y permiten al administrador compar

     Manual de Instalación

Requisitos previos:
- Python 3.5 o superior
- Pip (administrador de paquetes de Python)
- Git (opcional)

Configuración inicial:
1. Clona el repositorio de GitHub del proyecto utilizando Git o descargando el archivo ZIP.
2. Crea un entorno virtual utilizando virtualenv o venv:
```shell
python3 -m venv myenv
```
3. Activa el entorno virtual:
```shell
source myenv/bin/activate
```
4. Instala las dependencias del proyecto con Pip:
```shell
pip install -r requirements.txt
```
5. Configura la base de datos en settings.py. Por defecto, el proyecto utiliza una base de datos SQLite. Si deseas utilizar una base de datos diferente, deberás actualizar esta configuración. A continuación se muestra un ejemplo de configuración:

```python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'nombre_base_datos',
        'USER': 'usuario_base_datos',
        'PASSWORD': 'contraseña_base_datos',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    }
}
```

Ejecución del proyecto:
1. Asegúrate de que el entorno virtual esté activado:
```shell
source myenv/bin/activate
```
2. Crea las tablas en la base de datos:
```shell
python manage.py migrate
```
3. Crea un superusuario para acceder al panel de administración:
```shell
python manage.py createsuperuser
```
4. Ejecuta el servidor de desarrollo:
```shell
python manage.py runserver
```
5. Abre un navegador web y ve a http://localhost:8000 para ver el proyecto en ejecución.

Información adicional:
- La página de administración se encuentra en http://localhost:8000/admin y se puede acceder con las credenciales del superusuario creado en el paso 3.
- Para actualizar la base de datos con los cambios de modelos, utiliza el comando "python manage.py makemigrations" seguido de "python manage.py migrate".
- Si estás utilizando una base de datos diferente a SQLite, es posible que necesites instalar el controlador correspondiente para Python (por ejemplo, para MySQL: pip install mysqlclient).