Python Monitor Water Falls(3)django restful framework

Python Monitor Water Falls(3)django restful framework

Sqlite browser to see the data
http://sqlitebrowser.org/

Set water record module
>django-admin.py startapp waterrecord

Set up the models.py to define a ORM layer to persist the data in sqlite
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models

class WaterRecord(models.Model):
    waterName = models.CharField('water_name', max_length=50)
    released = models.BooleanField('released', default = False)
    releasedDate = models.CharField('released_date', max_length=20) #2018-01-16
    updateTime = models.DateTimeField('update_time', auto_now=True)
    createTime = models.DateTimeField('create_time', auto_now_add=True)

    def __unicode__(self):
        return self.waterName + self.releasedDate

Add this to the settings.py to enable this module
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'restful_api.waterrecord',
]

Models had some changes, so
>./manage.py makemigrations
>./manage.py migrate

Check the Database Information
>python manage.py shell
>>>from restful_api.waterrecord.models import WaterRecord
>>>WaterRecord.objects.all()
<QuerySet [<WaterRecord: MableFalls2018-01-01>, <WaterRecord: MableFalls2018-01-01>, <WaterRecord: MableFalls2018-01-02>]>

Serializer to support the JSON to Python Object and Object to JSON in serializers.py
# -*- coding: utf-8 -*-
from rest_framework import serializers
from .models import WaterRecord

class WaterRecordSerializer(serializers.ModelSerializer):
    class Meta:
        model = WaterRecord
        fields = ('id', 'waterName', 'released', 'releasedDate')

URL Mapping witch is helpful function from the framework in urls.py
# -*- coding: utf-8 -*-
from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^waterrecords/$', views.water_record_list, name='water_record_list'),
    # url(r'^waterrecords/$', views.WaterRecordList.as_view(), name='water_record_list'),
    # url(r'^waterrecords/$', views.WaterRecordListCreate.as_view(), name='water_record_list'),
    url(r'^waterrecords/(?P<pk>[0-9]+)$', views.water_record_detail, name='water_record_detail'),
]

Following the documents, I put a lot of different ways of views.py implementation there, but we only use the last 2 methods
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render
from rest_framework.decorators import api_view
from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework import generics

from .models import WaterRecord
from .serializers import WaterRecordSerializer

# APIView
class WaterRecordList(APIView):
    def get(self, request, format=None):
        items = WaterRecord.objects.all()
        serializer = WaterRecordSerializer(items, many=True)
        return Response(serializer.data)
    def post(self, request, format=None):
        serializer = WaterRecordSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

# ListCreateAPIView
class WaterRecordListCreate(generics.ListCreateAPIView):
    queryset = WaterRecord.objects.all()
    serializer_class = WaterRecordSerializer

# api_view
@api_view(['GET', 'POST'])
def water_record_list(request):
    '''
    List all items or create a new item
    '''
    if request.method == 'GET':
        items = WaterRecord.objects.all()
        serializer = WaterRecordSerializer(items, many=True)
        return Response(serializer.data)
    elif request.method == 'POST':
        serializer = WaterRecordSerializer(data = request.data)
        if serializer.is_valid():
            item = serializer.validated_data
            result, created = WaterRecord.objects.get_or_create(
                waterName=item['waterName'],
                releasedDate=item['releasedDate'],
                defaults = item)
            serializerResult = WaterRecordSerializer(result)
            return Response(serializerResult.data, status = status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

@api_view(['GET', 'PUT', 'DELETE'])
def water_record_detail(request, pk):
    try:
        item = WaterRecord.objects.get(pk=pk)
    except WaterRecord.DoesNotExist:
        return Response(status = status.HTTP_404_NOT_FOUND)

    if request.method == 'GET':
        serializer = WaterRecordSerializer(item)
        return Response(serializer.data)
    elif request.method == 'PUT':
        serializer = WaterRecordSerializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    elif request.method == 'DELETE':
        item.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

Deployment
Directly run that
>python manage.py runserver

Install the deployment tool
>pip install gunicorn

Libraries, pick up one is fine.
>pip install eventlet
>pip install greenlet
>pip install gevent

It works
>gunicorn restful_api.wsgi

Setting file
>cat gunicorn.py.ini
import multiprocessing

bind = "0.0.0.0:8000"

workers = multiprocessing.cpu_count() * 2 + 1

Run the command
>gunicorn -c gunicorn.py.ini restful_api.wsgi

Command to curl the RESTful API about water record
>curl http://localhost:8000/api/waterrecords/

>curl -X POST http://localhost:8000/api/waterrecords/ -d "waterName=MableFalls&released=true&releasedDate=2018-01-01"

>curl -X DELETE http://localhost:8000/api/waterrecords/1

>curl -X PUT http://localhost:8000/api/waterrecords/2 -d "waterName=MableFalls&released=false&releasedDate=2018-01-01"

I really like to deploy in Docker as follow:
start.sh
#!/bin/sh -ex

#start the service
cd /share/water-monitor/restful_api
gunicorn -c gunicorn.py.ini restful_api.wsgi

Makefile to support the build and run
IMAGE=sillycat/public
TAG=water-monitor-restful-api
NAME=water-monitor-restful-api

docker-context:

build: docker-context
   docker build -t $(IMAGE):$(TAG) .

run:
   docker run -d -p 8000:8000 -v /opt/water-monitor/restful_api:/share/water-monitor/restful_api --name $(NAME) $(IMAGE):$(TAG)

debug:
   docker run -ti -p 8000:8000 -v /opt/water-monitor/restful_api:/share/water-monitor/restful_api --name $(NAME) $(IMAGE):$(TAG) /bin/bash

clean:
   docker stop ${NAME}
   docker rm ${NAME}

logs:
   docker logs ${NAME}

publish:
   docker push ${IMAGE}:${TAG}

fetch:
   docker pull ${IMAGE}:${TAG}

Dockerfile to adjust all the ENV
#Set up FTP in Docker

#Prepre the OS
FROM resin/raspberrypi3-python
MAINTAINER Carl Luo <[e-mail]>

ENV DEBIAN_FRONTEND noninteractive
RUN apt-get -y update
RUN apt-get -y dist-upgrade

#install the software
RUN pip install django
RUN pip install djangorestframework
RUN pip install markdown
RUN pip install django-filter
RUN pip install gunicorn

RUN pip install greenlet
RUN pip install gevent
RUN pip install eventlet

#start the application
EXPOSE  8000
RUN     mkdir -p /app/
ADD     start.sh /app/
WORKDIR /app/
CMD    [ "./start.sh" ]

References:
more example
http://www.cnblogs.com/ccorz/p/djangorestframework-shi-yong-li-zi.html

http://sillycat.iteye.com/blog/2408979

Python Lover
http://sillycat.iteye.com/blog/2116834
http://sillycat.iteye.com/blog/2116836
http://sillycat.iteye.com/blog/2117212
http://sillycat.iteye.com/blog/2117576
http://sillycat.iteye.com/blog/2188140

Python Console
http://sillycat.iteye.com/blog/2372912
http://sillycat.iteye.com/blog/2373528
http://sillycat.iteye.com/blog/2373531
http://sillycat.iteye.com/blog/2373701

http://www.django-rest-framework.org/tutorial/1-serialization/
https://github.com/encode/rest-framework-tutorial
https://github.com/codingforentrepreneurs/Blog-API-with-Django-Rest-Framework
https://github.com/BurkovBA/django-rest-framework-mongoengine-example