Kom godt i gang med Django-kanaler

Django sporer ikke, om en bruger er logget ind, så vi skal lave en simpel model til at gøre det for os. Opret en LoggedInUser model med en en-til-en forbindelse til vores Bruger model i example_channels/example/models.py :

from django.conf import settings
from django.db import models


class LoggedInUser(models.Model):
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL, related_name='logged_in_user')

Vores app opretter en LoggedInUser forekomst, når en bruger logger på, og appen sletter forekomsten, når brugeren logger ud.

Foretag skemamigreringen, og migrér derefter vores database for at anvende ændringerne.

(env)$ python manage.py makemigrations
(env)$ python manage.py migrate

Opdater derefter vores brugerlistevisning iexample_channels/example/views.py , for at hente en liste over brugere, der skal gengives:

from django.contrib.auth import get_user_model, login, logout
from django.contrib.auth.decorators import login_required
from django.contrib.auth.forms import AuthenticationForm, UserCreationForm
from django.core.urlresolvers import reverse
from django.shortcuts import render, redirect


User = get_user_model()


@login_required(login_url='/log_in/')
def user_list(request):
    """
    NOTE: This is fine for demonstration purposes, but this should be
    refactored before we deploy this app to production.
    Imagine how 100,000 users logging in and out of our app would affect
    the performance of this code!
    """
    users = User.objects.select_related('logged_in_user')
    for user in users:
        user.status = 'Online' if hasattr(user, 'logged_in_user') else 'Offline'
    return render(request, 'example/user_list.html', {'users': users})


def log_in(request):
    form = AuthenticationForm()
    if request.method == 'POST':
        form = AuthenticationForm(data=request.POST)
        if form.is_valid():
            login(request, form.get_user())
            return redirect(reverse('example:user_list'))
        else:
            print(form.errors)
    return render(request, 'example/log_in.html', {'form': form})


@login_required(login_url='/log_in/')
def log_out(request):
    logout(request)
    return redirect(reverse('example:log_in'))


def sign_up(request):
    form = UserCreationForm()
    if request.method == 'POST':
        form = UserCreationForm(data=request.POST)
        if form.is_valid():
            form.save()
            return redirect(reverse('example:log_in'))
        else:
            print(form.errors)
    return render(request, 'example/sign_up.html', {'form': form})

Hvis en bruger har en tilknyttet LoggedInUser , så registrerer vi brugerens status som "Online", og hvis ikke, er brugeren "Offline". Vi tilføjer også en @login_required dekorator til både vores brugerliste og log ud visninger for kun at begrænse adgangen til registrerede brugere.

Tilføj også importerne:

from django.contrib.auth import get_user_model, login, logout
from django.contrib.auth.decorators import login_required

På dette tidspunkt kan brugere logge ind og ud, hvilket vil udløse serveren til at sende beskeder til klienten, men vi har ingen mulighed for at vide, hvilke brugere der er logget ind, når brugeren logger på første gang. Brugeren ser kun opdateringer, når en anden brugers statusændringer. Det er her LoggedInUser kommer i spil, men vi har brug for en måde at oprette en LoggedInUser på forekomst, når en bruger logger på, og slet det derefter, når denne bruger logger ud.

Django-biblioteket indeholder en funktion kendt som signaler, der udsender meddelelser, når visse handlinger forekommer. Applikationer kan lytte efter disse meddelelser og derefter reagere på dem. Vi kan udnytte to nyttige, indbyggede signaler (user_logged_in og user_logged_out ) for at håndtere vores LoggedInUser adfærd.

Inden for "example_channels/example" skal du tilføje en ny fil kaldet signals.py :

from django.contrib.auth import user_logged_in, user_logged_out
from django.dispatch import receiver
from example.models import LoggedInUser


@receiver(user_logged_in)
def on_user_login(sender, **kwargs):
    LoggedInUser.objects.get_or_create(user=kwargs.get('user'))


@receiver(user_logged_out)
def on_user_logout(sender, **kwargs):
    LoggedInUser.objects.filter(user=kwargs.get('user')).delete()

Vi er nødt til at gøre signalerne tilgængelige i vores app-konfiguration, example_channels/example/apps.py :

from django.apps import AppConfig


class ExampleConfig(AppConfig):
    name = 'example'

    def ready(self):
        import example.signals

Opdater example_channels/example/__init__.py også:

default_app_config = 'example.apps.ExampleConfig'

Sanity Check

Nu er vi færdige med at kode og er klar til at oprette forbindelse til vores server med flere brugere for at teste vores app.

Kør Django-serveren, log ind som bruger og besøg hjemmesiden. Vi skulle se en liste over alle brugerne i vores app, hver med statussen "Offline". Åbn derefter et nyt inkognitovindue og log ind som en anden bruger og se begge skærme. Lige når vi logger ind, opdaterer den almindelige browser brugerstatus til "Online". Fra vores inkognitovindue ser vi, at den bruger, der er logget på, også har status som "Online". Vi kan teste WebSockets ved at logge ind og ud på vores forskellige enheder med forskellige brugere.

Ved at observere udviklerkonsollen på klienten og serveraktiviteten i vores terminal kan vi bekræfte, at WebSocket-forbindelser dannes, når en bruger logger på, og ødelægges, når en bruger logger ud.

[2017/02/20 00:15:23] HTTP POST /log_in/ 302 [0.07, 127.0.0.1:55393]
[2017/02/20 00:15:23] HTTP GET / 200 [0.04, 127.0.0.1:55393]
[2017/02/20 00:15:23] WebSocket HANDSHAKING /users/ [127.0.0.1:55414]
[2017/02/20 00:15:23] WebSocket CONNECT /users/ [127.0.0.1:55414]
[2017/02/20 00:15:25] HTTP GET /log_out/ 302 [0.01, 127.0.0.1:55393]
[2017/02/20 00:15:26] HTTP GET /log_in/ 200 [0.02, 127.0.0.1:55393]
[2017/02/20 00:15:26] WebSocket DISCONNECT /users/ [127.0.0.1:55414]