Modificar plantilla de Administración en Django 1.11 + (1.8+)

El siguiente snippet pretende ilustrar de forma directa y sencilla cómo funciona el sistema de plantillas que Django incorpora desde la versión 1.8, aplicado a la sobre-escritura de la plantilla de administración. Para detalles técnicos está la fabula documentación de Django.

Comencemos creando una carpeta de nombre templates, dentro de esta otra llamada admin, y dentro de admin un archivo al que llamaremos base_site.html. La estructura deberá quedar como sigue:

proyecto
*proyecto
*app1
*app2
*appn
*templates
**admin
***base_site.html

A continuación entra en la carpeta de plantillas de administración de Django en Github: https://github.com/django/django/tree/master/django/contrib/admin/templates/admin

Dentro de este directorio busca el archivo base_site.html. Ábrelo, copia el código que haya en su interior y pégalo en el archivo base_site.html que creaste en el paso anterior.

{% extends "admin/base.html" %}

{% block title %}Título de la página{% endblock %}

{% block branding %}


<h1 id="site-name"><a href="{% url 'admin:index' %}">Cabecera de la página</a></h1>


{% endblock %}

{% block nav-global %}{% endblock %}

Te quedará algo así, y aquí podrás modificar lo que tú quieras, pero para que los cambios aun se vean reflejados aun nos queda un paso más.

Entra en el archivo settings.py de tu proyecto y encuentra el bloque de código TEMPLATES. Dentro del diccionario DIRS, introduce la siguiente ruta:

os.path.join(BASE_DIR, ‘templates’),

Deberá quedar algo como:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [
            os.path.join(BASE_DIR, 'templates'),
        ],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },

]

Y ahora sí, al recargar tu página de administración podrás ver que los cambios han surtido efecto. A partir de esto, todo es probar a modificar lo que quieras a partir del proyecto Django original en GitHub.

Registro de usuario en Django Rest Framework

Mi solución de registro de usuarios a través de una API rest. No he encontrado ejemplos completos en ninguna parte, y este código bien pudiera no ser óptimo.

#serializers.py
class UserViewSet(viewsets.ModelViewSet):
    """
    A viewset that provides the standard actions
    """
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = (AllowAny, )

    def create(self, request, *args, **kwargs):
        """
        http POST 127.0.0.1:8000/users/ By default asks for permission.
        :param request:
        :return:
        """
        serializer = UserSerializer(data=request.data)
        if serializer.is_valid():
            user = serializer.create(validated_data=request.data)
            #serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
#views.py
class UserSerializer(serializers.ModelSerializer):
    class Meta:
        """
        Returns all the Avatars id related to one user. Must set the related_name from the many part.
        """
        avatars = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
        model = User
        fields = ('id', 'email', 'avatars', 'account_type', 'password', 'username')

    def create(self, validated_data):
        """
        We've to override the create serializer method in order to call to our custom create_user
        http://www.django-rest-framework.org/api-guide/serializers/#saving-instances
        :param validated_data: Incoming POST data
        :return: A created user instance
        """
        account_type = AccountType.objects.get(pk=validated_data['account_type'])
        email = validated_data['email']
        password = validated_data['password']
        username = validated_data['email']
        return User.objects.create_user(username=username, account_type=account_type, email=email, password=password) # Alternative: User.objects.create(**validated_data)

Fecha de creación y edición automáticas en Django

En Django la fecha de creación y modificación no se añade por defecto a nuestros modelos, como sí ocurre en otros frameworks como Ruby On Rails. La forma más elegante de añadir esta funcionalidad a tus modelos es crear una clase base que herede de models.Model y luego hacer que todos tus modelos hereden de la misma.

class BaseModel(models.Model):
    created_date = models.DateTimeField(_('Date created'), auto_now_add=True)
    modified_date = models.DateTimeField(_('Date modified'), auto_now=True)

    class Meta:
        abstract = True

El resto de nuestros modelos donde queramos tener las fechas de creación y actualización automáticas deberán ser del tipo:

class AccountType(BaseModel):
    name = models.CharField(_('Name of this account type ie: Free'), blank=False, max_length=254)
    description = models.TextField(_('Explain the user what he can and can not do with this account'), blank=True, max_length=512)

Obtener link de un ImageField en Django Rest Framework

ImageField difiere de FileField en cuanto a que el método .link no está disponible. Enviar vía DRF (Django Rest Framework) el link a una imagen no es un proceso “trivial”. Mi implementación se basa en usar Serializer Method Field. El código que sigue creo que es bastante esclarecedor:

serializers.py

from rest_framework import serializers
from .models import User, Avatar
from django.conf import settings

class AvatarSerializer(serializers.ModelSerializer):
    """ Returns all the avatars """
    download_link = serializers.SerializerMethodField()
    class Meta:
        model = Avatar
        fields = ('id', 'user', 'avatar', 'download_link')

    # GET Must be in front
    def get_download_link(self, obj):
        return '%s/%s' % (settings.MEDIA_ROOT , obj.avatar.name)

models.py

class Avatar(models.Model):
    """ Related_name must be set in order to catch related user avatars in the serializer"""
    user = models.ForeignKey(User, related_name='avatars')
    is_active = models.BooleanField(_('Show this avatar'), default=False)
    avatar = models.ImageField(_('Your profile picture'), blank=False, upload_to=set_avatar_directory, help_text=_('Let others see a picture or artwork that identifies you.'))

Aun así, es posible que exista una forma más óptima de llevar a cabo este proceso. Si la conoces no dudes en escribir un comentario o ponerte en contacto conmigo.

Fecha por defecto en modelo Django 1.11

Existen dos formas de incluir una fecha por defecto en Django. La primera, que había estado empleando en versiones del framework anteriores sería la siguiente:

import datetime
date_of_birth = models.DateField(_('Date of Birth'), default=datetime.date.today())

Sin embargo la forma óptima de establecer esta fecha por defecto es empleando el módulo de Django timezone:

from django.utils import timezone
date_of_birth = models.DateField(_('Date of Birth'), default=timezone.now)

El motivo tiene que ver con el sistema de zonas horarias que viene por defecto activado en Django. Si se emplea la primera opción, tu aplicación no operará de forma correcta cuando se trate de fechas en distintas partes del mundo o del año (cambios anuales).

Configuración rápida mysql Django para Ubuntu 16 / 14

Enlazar mysql con Django puede dar más de un quebradero de cabeza si no se sigue un orden secuencial de instalación de paquetes.

En primer lugar, asegúrate de instalar un servidor de mysql en tu servidor o equipo de desarrollo. Instala tambén libmysqlclient-dev, necesario para conectar python con mysql.

sudo apt-get install mysql-server
sudo apt-get install libmysqlclient-dev

Ahora instala mediante pip o tu gestor de paquetes python la librería mysqlclient.

pip install mysqlclient

A continuación entra en tu proyecto Django y abre el archivo settings.py. En la sección DATABASES, introduce el siguiente fragmento de código:

DATABASES = {
'default': {
        'ENGINE': 'django.db.backends.mysql',
        'OPTIONS': {
            'read_default_file': os.path.join(BASE_DIR, 'db.cnf'),
        },
    }
}

Por último, crea un archivo con nombre db.cnf en el directorio raíz de tu aplicación Django, y copia el siguiente texto, sustituyendo las variables por tus datos de configuración:

[client]
database = nombre_de_tu_db
user = usuario_mysql
password = contraseña_usuario
default-character-set = utf8

Esto equivaldría a:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'USER': 'usuario_mysql',
        'PASSWORD': 'contraseña_usuario'
        'NAME': 'nombre_de_tu_db',
    },
}

La base de datos que introduzcas debe ser creada de forma manual, y tras iniciar el servidor y ver que todo funciona correctamente recuerda hacer todas las migraciones pertinentes.

Crear un modelo de autenticación personalizado en Django

A modo de apunte dejo los pasos a seguir para crear un modelo de autenticación en Django 1.11. No voy a ahondar en ningún detalle ya que estos se pueden encontrar en:

1: Registra la app en la cuál vayas a especificar tu modelo de usuario dentro de settings.py.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'tu_app'
]

2: En models.py de ‘tu_app’ añade lo siguiente:

from django.db import models
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    pass

3: De vuelta en settings.py añade la siguiente línea:

AUTH_USER_MODEL = 'tu_app.User'

(No importa en qué punto del documento la incluyas)

4: Entra en admin.py de ‘tu_app’ y registra la siguiente entrada:

from django.contrib import admin
from .models import User
from django.contrib.auth.admin import UserAdmin

admin.site.register(User, UserAdmin)

5: Migraciones.

python manage.py makemigrations
python manage.py migrate

Y listo.

Bloquear puertos League of Legends – Segunda opción

 

Esta guía parte desde el punto tercero de esta otra: https://erwol.com/es/blog/bloquea-el-league-of-legends-lol-en-tu-red/

Doy por hecho que ya has accedido a la configuración de tu router. Ahora debes acceder a la configuración de puertos de tu router y bloquear los siguientes:

Ten en cuenta que estos mismos puertos podrían ser usados por otras aplicaciones de tu sistema que, tras el bloqueo, se quedarán sin conexión. 

UDP: 5000 – 5500  – Cliente League of Legends

TCP: 8393 – 8400 – Master server

TCP: 2099 – PVP.Net

TCP: 5223 – PVP.Net

TCP: 5222 – PVP.Net

Como las opciones para cerrar puertos difieren de un modelo de router a otro, nuevamente tendrás que echar mano del manual del tuyo, aunque probablemente esta opción sí que esté disponible en tu modelo.

 

 

¿Cuál es la dirección IP local de mi router?

La dirección ip local de tu router no es más que la puerta de acceso por la que todos los dispositivos conectados al mismo (tu pc, móvil, impresora o tablet). La mayoría de las veces necesitamos saber esta dirección para arreglar problemas de conectividad o para realizar configuraciones al router.

Los pasos a seguir para obtener la dirección son los siguientes:

1. Aunque suene obvio, conectarnos a la red del router. Por ejemplo al WiFi de casa, o por cable directamente al aparato (si sabes hacerlo). En principio con estar conectado al WiFi vas bien.

2. Entra al “símbolo del sistema”. Para ello escribe en la búsqueda del menú de inicio de Windows la palabra cmd y haz clic en el resultado que tenga este aspecto:

3. Se abrirá una ventana negra en la que debes escribir ipconfig y pulsar la tecla enter. Una vez pulses la tecla enter aparecerá un resultado como el siguiente:

4: No te preocupes porque los números que aparezcan en tu pantalla sean distintos a los de la imagen.

4.1 Si estás conectado sólo por WiFi localiza el recuadro rojo “Adaptador de LAN inalámbrica Wi-Fi” y una vez lo encuentres encuentra el recuadro verde “Puerta de enlace predeterminada” y copia el número que haya a su derecha. En mi caso el 192.168.1.1. Listo, ya tienes tu ip lo cal. Si vienes de otra guía, puedes volver a la misma y continuar el proceso.

4.2 Si estás conectado por Ethernet (cable) debes encontrar la sección “Adaptador de Ethernet” y dentro, la “Puerta de enlace predeterminada“. En mi caso el 192.168.1.1 y listo, ya tienes tu ip local. Si vienes de otra guía, puedes volver a la misma y continuar el proceso.

Añadir un entorno virtual (virtualenv) a Pycharm

Si te encuentras trabajando con Pycharm y a la hora de hacer algún import te encuentras con errores como “Unresolved reference ‘django’“, probablemente se te haya pasado incluir en el path de Pycharm la ruta al entorno virtual con el que estés trabajando. También puede ocurrir que realmente se te haya pasado instalar la dependencia, pero esa es otra historia.

Para añadir tu virtualenv simplemente abre tu proyecto con Pycharm, haz clic en File > Settings > Project: nombre_de_tu_proyecto > Project Interpreter > Rueda dentada > Add local > Busca tu virtual env/bin/python > Ok

Y listo, ya no debería dar problemas.