webentwicklung-frage-antwort-db.com.de

Ein ... Erstellen REST API für eine Django-Anwendung

Ich erhielt einen Auftrag, bei dem ich eine Anwendungs-API (REST) ​​mithilfe der Django-Technologie erstellen muss. Ich muss nur in der Lage sein, die Einträge von mehreren Modellen zu lesen (GET), sie zu verknüpfen und sie im JSON-Format (ein oder mehrere Objekte) zurückzugeben. Das Json-Schema und ein Beispiel für eine entsprechende Json-Datei wurden mir bereits gegeben.

Da dies das erste Mal ist, dass ich eine API erstellt habe und ich mit Django nicht sehr vertraut bin, bitte ich Sie um einige Anleitungen.

Ich habe zwei Frameworks gegoogelt, die anscheinend am beliebtesten sind:

Wie ich gesehen habe, ermöglichen Ihnen diese beiden die schnelle Einrichtung Ihrer API für Ihre Anwendung. Kann ich ein benutzerdefiniertes JSON-Format mit einem davon erstellen, oder gibt es eine andere Möglichkeit, dies zu tun?

28
TheAptKid

Tastypie verwenden: -

models.py

class User(Document):
    name = StringField()

api.py

from tastypie import authorization
from tastypie_mongoengine import resources
from project.models import *
from tastypie.resources import *

class UserResource(resources.MongoEngineResource):
class Meta:
    queryset = User.objects.all()
    resource_name = 'user'
    allowed_methods = ('get', 'post', 'put', 'delete','patch')
    authorization = authorization.Authorization()

url.py

from tastypie.api import Api
from projectname.api import *

v1_api = Api(api_name='v1')
v1_api.register(UserResource())

Javascript (jQuery)

Dieses Beispiel betrifft eine GET-Anfrage:

$(document).ready(function(){
    $.ajax({
       url: 'http://127.0.0.1:8000/api/v1/user/?format=json',
       type: 'GET',                   
       contentType: 'application/json',
       dataType: 'json',
       processData: false,
       success: function(data){
           alert(data)
       //here you will get the data from server
       },
       error: function(jqXHR, textStatus, errorThrown){
              alert("Some Error")                                  
       }
    })
})

Ändern Sie bei einer POST - Anforderung den Typ in POST und senden Sie die data im richtigen Format

Weitere Informationen finden Sie in den Tastypie-Dokumenten

18
Nullify

Ich habe Django REST verwendet, und im Allgemeinen gefällt es, wie es funktioniert. Die automatisch generierten, von Menschen durchsuchbaren API-Bildschirme sind ebenfalls sehr praktisch.

Theoretisch gibt es kein Darstellungsformat vor; Sie definieren "Serialisierer", die angeben, welche Felder und Inhalte in welchem ​​seriellen Format angezeigt werden sollen. Einige Formate sind jedoch einfacher als andere. Letztendlich können Sie einfache funktionsbasierte Ansichten hinzufügen, die genau das gewünschte JSON-Objekt zurückgeben. Selbst in diesem Fall reduziert das Framework den Arbeitsaufwand für eine vollständige API erheblich.

Wie bei Django ist es am besten, das gesamte Tutorial mindestens einmal zu absolvieren, um ein Gefühl dafür zu bekommen, was wohin geht. Geben Sie der Versuchung nicht nach, die Beispiele an Ihre spezifischen Probleme anzupassen, da dies die Dinge nur komplizierter macht. Nachdem Sie das gesamte Lernprogramm beendet haben, können Sie selbst feststellen, wie nahe die "einfachen" Formate Ihren Bedürfnissen entsprechen.

12
Javier

Mit Django REST Framework

Mit Django 1.8.4 und DRF 3.3.3.

Hier ist eine sehr einfache benutzerdefinierte JSONSchemaField-Klasse, die Sie mit Django REST Framework und dem jsonschema-Paket (verfügbar über pip install jsonschema) unterstützen können. 

Das benutzerdefinierte Feld erbt mit einigen kleinen Änderungen von der vorhandenen JSONField-Klasse von DRF. Es fügt den Schritt hinzu, eingehende JSON anhand der JSONSchema-Definition zu überprüfen. Wenn die Validierung erfolgreich ist, wird das Django-Modell TextField zum Speichern/Abrufen der unformatierten JSON-Zeichenfolge verwendet.

In app/serializers.py

import json
from rest_framework import serializers
from jsonschema import validate  # validates incoming data against JSONSchema
from jsonschema.exceptions import ValidationError as JSONSchemaValidationError
from .models import Lesson

from .jsonschema import (
    notes_schema,
)


class JSONSchemaField(serializers.JSONField):
# Custom field that validates incoming data against JSONSchema, 
# Then, if successful, will store it as a string.

    def __init__(self, schema, *args, **kwargs):
        super(JSONSchemaField, self).__init__(*args, **kwargs)
        self.schema = schema

    def to_representation(self, obj):
        return json.loads(obj)

    def to_internal_value(self, data):
        try:
            validate(data, self.schema)
        except JSONSchemaValidationError as e:
            raise serializers.ValidationError(e.message)

        return super(JSONSchemaField, self).to_internal_value(json.dumps(data))


class LessonSerializer(serializers.HyperlinkedModelSerializer):
    notes = JSONSchemaField(notes_schema)

    class Meta:
        model = Lesson
        fields = ('url', 'title', 'bpm', 'notes')

In app/models.py

from Django.db import models


class Lesson(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    title = models.CharField(max_length=100, blank=True, default='Untitled')
    bpm = models.DecimalField(max_digits=5, decimal_places=2, default=120.00)
    notes = models.TextField()

    class Meta:
        ordering = ('created',)

In app/jsonschema.py

notes_schema = {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "name": {
                "type": "string",
                "pattern": "^[A-G][#b]?[0-9]$"
            },
            "duration": {
                "type": "string",
                "pattern": "^\d+\/\d+$"
            }
        },
        "required": ["name", "duration"]
    }
}

notes_example = [{"name": "C#4", "duration": "1/4"},
                 {"name": "A4", "duration": "1/32"}]

In app/views.py

from rest_framework import viewsets

from .models import Lesson
from .serializers import LessonSerializer


class LessonViewSet(viewsets.ModelViewSet):
    queryset = Lesson.objects.all()
    serializer_class = LessonSerializer
4
jfunk

Eine weitere gute Kombination ist Django-Restless, https://Django-restless.readthedocs.org/de/latest/ , und Sie können nur Ihre eigenen Serializer innerhalb Ihrer Modelle erstellen. Zum Beispiel

## Models
class Blog(models.Model):
    title = models.CharField()
    user = models.ForeignKey(settings.AUTH_USER_MODEL)
    text = models.TextField()

    def __init__(self, *args, **kwargs):
        self.super().__init__(*args, **kwargs)
        self.schema = { 
            "title" : self.title,
            "text"  : self.text,
            "user"  : self.user.full_name
        }

    @property
    def list_view(self):
        fields = ["title","user"]
        return {key: self.schema[key] for key in fields}

    @property
    def detail_view(self):
        fields = ["title","text","user"]
        return {key: self.schema[key] for key in fields}

## views
from restless.views import Endpoint
from .models import *
class BlogList(Endpoint):
    def get(self, request):
        posts = [blog.list_view for blog in Blog.objects.all()]
        return json.dumps({posts})

sie können auch andere HTTP-Verben als Methoden hinzufügen und Formulare zur Überprüfung dieser Daten verwenden.

4
user1876508

Wir verwenden Django-Kolben auf der Serverseite, um REST -Aufrufe abzuwickeln. 

[Client] ← REST → [Web-Server] - [Django/ Django-Kolben ]

Auch die Antwort in sehen Sie hier.

0
Ming Chan