Erste Schritte mit Django-Kanälen

HINWEIS: Versuchen Sie es mit michael als Benutzername und johnson123 als Passwort.

Der sign_up view leitet uns zum log_in weiter Ansicht, und von dort aus können wir unseren neu erstellten Benutzer authentifizieren.

Nachdem wir uns angemeldet haben, können wir unsere neuen Authentifizierungsansichten testen.

Verwenden Sie das Anmeldeformular, um in Vorbereitung auf den nächsten Abschnitt mehrere neue Benutzer zu erstellen.

Anmeldebenachrichtigungen

Wir haben eine grundlegende Benutzerauthentifizierung, die funktioniert, aber wir müssen immer noch eine Liste von Benutzern anzeigen, und wir brauchen den Server, um der Gruppe mitzuteilen, wenn sich ein Benutzer an- und abmeldet. Wir müssen unsere Verbraucherfunktionen so bearbeiten, dass sie direkt nach a eine Nachricht senden Client verbindet und kurz bevor ein Client die Verbindung trennt. Die Nachrichtendaten enthalten den Benutzernamen und den Verbindungsstatus des Benutzers.

Aktualisieren Sie example_channels/example/consumers.py so:

import json
from channels import Group
from channels.auth import channel_session_user, channel_session_user_from_http


@channel_session_user_from_http
def ws_connect(message):
    Group('users').add(message.reply_channel)
    Group('users').send({
        'text': json.dumps({
            'username': message.user.username,
            'is_logged_in': True
        })
    })


@channel_session_user
def ws_disconnect(message):
    Group('users').send({
        'text': json.dumps({
            'username': message.user.username,
            'is_logged_in': False
        })
    })
    Group('users').discard(message.reply_channel)

Beachten Sie, dass wir Dekoratoren zu den Funktionen hinzugefügt haben, um den Benutzer aus der Django-Sitzung zu holen. Außerdem müssen alle Nachrichten JSON-serialisierbar sein, also geben wir unsere Daten in einen JSON-String aus.

Aktualisieren Sie als Nächstes example_channels/example/templates/example/user_list.html :

{% extends 'example/_base.html' %}

{% block content %}
  <a href="{% url 'example:log_out' %}">Log out</a>
  <br>
  <ul>
    {% for user in users %}
      <!-- NOTE: We escape HTML to prevent XSS attacks. -->
      <li data-username="{{ user.username|escape }}">
        {{ user.username|escape }}: {{ user.status|default:'Offline' }}
      </li>
    {% endfor %}
  </ul>
{% endblock content %}

{% block script %}
  <script>
    var socket = new WebSocket('ws://' + window.location.host + '/users/');

    socket.onopen = function open() {
      console.log('WebSockets connection created.');
    };

    socket.onmessage = function message(event) {
      var data = JSON.parse(event.data);
      // NOTE: We escape JavaScript to prevent XSS attacks.
      var username = encodeURI(data['username']);
      var user = $('li').filter(function () {
        return $(this).data('username') == username;
      });

      if (data['is_logged_in']) {
        user.html(username + ': Online');
      }
      else {
        user.html(username + ': Offline');
      }
    };

    if (socket.readyState == WebSocket.OPEN) {
      socket.onopen();
    }
  </script>
{% endblock script %}

Auf unserer Homepage erweitern wir unsere Benutzerliste, um eine Liste von Benutzern anzuzeigen. Wir speichern den Benutzernamen jedes Benutzers als Datenattribut, um das Auffinden des Benutzerelements im DOM zu erleichtern. Wir fügen unserem WebSocket auch einen Ereignis-Listener hinzu, der Nachrichten vom Server verarbeiten kann. Wenn wir eine Nachricht erhalten, parsen wir die JSON-Daten, finden den <li> -Element für den angegebenen Benutzer und aktualisieren Sie den Status dieses Benutzers.

Django verfolgt nicht, ob ein Benutzer angemeldet ist, daher müssen wir ein einfaches Modell erstellen, um dies für uns zu tun. Erstellen Sie einen LoggedInUser Modell mit einer Eins-zu-Eins-Verbindung zu unserem User Modell in 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')

Unsere App erstellt einen LoggedInUser Instanz, wenn sich ein Benutzer anmeldet, und die App löscht die Instanz, wenn sich der Benutzer abmeldet.

Führen Sie die Schemamigration durch und migrieren Sie dann unsere Datenbank, um die Änderungen zu übernehmen.

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

Aktualisieren Sie als Nächstes unsere Nutzerlistenansicht in example_channels/example/views.py , um eine Liste der zu rendernden Benutzer abzurufen:

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})

Wenn ein Benutzer einen zugeordneten LoggedInUser hat , dann erfassen wir den Status des Benutzers als „Online“, und wenn nicht, ist der Benutzer „Offline“. Wir fügen auch einen @login_required hinzu decorator für unsere Benutzerliste und Abmeldeansichten, um den Zugriff nur auf registrierte Benutzer zu beschränken.

Fügen Sie auch die Importe hinzu:

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

An diesem Punkt können sich Benutzer an- und abmelden, was den Server veranlasst, Nachrichten an den Client zu senden, aber wir haben keine Möglichkeit zu wissen, welche Benutzer angemeldet sind, wenn sich der Benutzer zum ersten Mal anmeldet. Der Benutzer sieht nur Updates, wenn die eines anderen Benutzers sind Statusänderungen. Hier ist der LoggedInUser kommt ins Spiel, aber wir brauchen eine Möglichkeit, einen LoggedInUser zu erstellen Instanz, wenn sich ein Benutzer anmeldet, und dann löschen, wenn sich dieser Benutzer abmeldet.

Die Django-Bibliothek enthält eine Funktion namens Signale, die Benachrichtigungen sendet, wenn bestimmte Aktionen auftreten. Anwendungen können auf diese Benachrichtigungen warten und dann darauf reagieren. Wir können zwei hilfreiche, eingebaute Signale ausnutzen (user_logged_in und user_logged_out ), um unseren LoggedInUser zu behandeln Verhalten.

Fügen Sie in „example_channels/example“ eine neue Datei mit dem Namen signals.py hinzu :

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()

Wir müssen die Signale in unserer App-Konfiguration verfügbar machen, example_channels/example/apps.py :

from django.apps import AppConfig


class ExampleConfig(AppConfig):
    name = 'example'

    def ready(self):
        import example.signals

Aktualisieren Sie example_channels/example/__init__.py auch:

default_app_config = 'example.apps.ExampleConfig'

Sicherheitsprüfung

Jetzt sind wir mit dem Programmieren fertig und bereit, uns mit mehreren Benutzern mit unserem Server zu verbinden, um unsere App zu testen.

Führen Sie den Django-Server aus, melden Sie sich als Benutzer an und besuchen Sie die Homepage. Wir sollten eine Liste aller Benutzer in unserer App sehen, jeder mit dem Status „Offline“. Öffnen Sie als Nächstes ein neues Inkognito-Fenster, melden Sie sich als anderer Benutzer an und sehen Sie sich beide Bildschirme an. Gleich beim Einloggen aktualisiert der normale Browser den Benutzerstatus auf „Online“. In unserem Inkognito-Fenster sehen wir, dass der angemeldete Benutzer auch den Status „Online“ hat. Wir können die WebSockets testen, indem wir uns mit verschiedenen Benutzern auf unseren verschiedenen Geräten an- und abmelden.

Durch Beobachtung der Entwicklerkonsole auf dem Client und der Serveraktivität in unserem Terminal können wir bestätigen, dass WebSocket-Verbindungen aufgebaut werden, wenn sich ein Benutzer anmeldet, und zerstört werden, wenn sich ein Benutzer abmeldet.

[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]