In the previous step we got the service running.
But, it's only serving up an HTML page.
In this step we'll figure out how to serve up some JSON.
For this, we need to create our REST app.
Our app will be a simple service for keeping track of user credentials.
We'll call it users.
python3 manage.py startapp users
We need to configure the users app, which includes:
- Making Django aware of our new app by changing settings.py
- Creating a
User model to store user credentials (i.e., username and password) in users/models.py
- Creating a serializer for our
User model, which converts the credential info into JSON in users/serializers.py
- Creating a view, or endpoint, for our
users service in users/views.py
- Adding a URL for the endpoint to rest/urls.py
Open the settings.py file.
Open rest/settings.py
You will want to make the INSTALLED_APPS section like the following, which adds two entries at the bottom of the list (find the list and replace it with the content shown).
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'users.apps.UsersConfig',
]
What did we just do?
The INSTALLED_APPS list tells Django which apps to install.
We need the REST framework, so we added that to the list.
We also added our User app that we created above.
Next, add a User model to models.py.
Open users/models.py
Add the following to the file.
from django.db import models
class User(models.Model):
username = models.CharField(max_length = 20)
password = models.CharField(max_length = 20)
What did we just do?
We need a place to store Cassandra records before we write them and after we read them.
The model contains classes to do that.
In this example, we created a User model class that maps to the table we will use.
The table will have two columns: username and password - just like our model.
We'll also create a serializers.py file to serialize the model.
Open users/serializers.py
Here's the serializer code.
from django.db import models
from rest_framework import serializers
from .models import User
class UserSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = '__all__'
What did we just do?
The job of the serializer class is to convert model classes to JSON and JSON to models.
Django does the heavy lifting for us, so we need to import the serializers package.
We also need to import our User model.
We name the class based on our model name (e.g., User) and add the word Serializer.
Notice that the UserSerializer class derives from the Django ModelSerializer class.
In the inner Meta class, we specify which fields we want to include in the serialization.
If we want to include all the fields, we can use '__all__'.
Alternatively, we can specify the fields we want to include in a tuple (e.g., ('username', 'password')).
Finally, edit the views.py file to serve up the JSON.
You see that we have hard-coded the returned values (i.e., MyName and MyPassword).
We'll see how to extract these values from Cassandra in the next steps.
Open users/views.py
Include this code.
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import User
from .serializers import UserSerializer
class User(APIView):
def get(self, request):
user = User()
user.username = 'MyName'
user.password = 'MyPassword'
serializer = UserSerializer(user)
return Response(serializer.data)
def post(self, request):
pass
What did we just do?
The users/view.py file contains the code that Django executes when the service receives a request.
You notice the two methods get() and post() that correspond to the HTTP GET and POST requests.
For now, we just create a User instance, load it up with some hard-coded values, pass it to the serializer and send the serialized results back to the client.
Finally, we'll add a url pattern to handle the request.
Open the rest/urls.py file.
Open rest/urls.py
Replace the contents of the file with the following.
from django.contrib import admin
from django.urls import path
from rest_framework.urlpatterns import format_suffix_patterns
from users import views
urlpatterns = [
path('admin/', admin.site.urls),
path('user/', views.User.as_view()),
]
urlpatterns = format_suffix_patterns(urlpatterns)
That's all there is to it.
Let's hit the service just to make sure it works.
curl 127.0.0.1:8000/user/
Outstanding! The service is now serving up JSON!
