Demo apps

Author: Emmanouil Konstantinidis

demo/project/accounts/__init__.py

@@ -0,0 +1,35 @@
+from django.db import models
+from django.contrib.auth.models import AbstractBaseUser
+
+
+class User(AbstractBaseUser):
+    created = models.DateTimeField(auto_now_add=True, db_index=True)
+    modified = models.DateTimeField(auto_now=True)
+
+    email = models.EmailField(unique=True, verbose_name='email address', max_length=255)
+    full_name = models.CharField(max_length=255)
+
+    is_active = models.BooleanField(default=False)
+    is_admin = models.BooleanField(default=False)
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['email', 'full_name']
+
+    def __str__(self):
+        return self.email
+
+    def has_perm(self, perm, obj=None):
+        "Does the user have a specific permission?"
+        # Simplest possible answer: Yes, always
+        return True
+
+    def has_module_perms(self, app_label):
+        "Does the user have permissions to view the app `app_label`?"
+        # Simplest possible answer: Yes, always
+        return True
+
+    @property
+    def is_staff(self):
+        "Is the user a member of staff?"
+        # Simplest possible answer: All admins are staff
+        return self.is_admin

demo/project/accounts/models.py

@@ -0,0 +1,32 @@
+from rest_framework import serializers
+from project.accounts.models import User
+
+
+class UserRegistrationSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = User
+        fields = ('email', 'full_name', 'password',)
+        extra_kwargs = {'password': {'write_only': True}}
+
+
+class UserProfileSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = User
+        fields = ('email', 'full_name', 'password', 'is_active')
+        extra_kwargs = {
+            'password': {'write_only': True}
+        }
+        read_only_fields = ('is_active',)
+
+
+class ResetPasswordSerializer(serializers.ModelSerializer):
+
+    id = serializers.CharField()
+    token = serializers.CharField()
+
+    class Meta:
+        model = User
+        fields = ('id', 'token', 'password',)
+        extra_kwargs = {'password': {'write_only': True}}

demo/project/accounts/serializers.py

@@ -0,0 +1,15 @@
+from django.conf.urls import url
+from project.accounts import views
+
+
+urlpatterns = [
+    url(r'^test/$', views.TestView.as_view(), name="test-view"),
+
+    url(r'^login/$', views.LoginView.as_view(), name="login"),
+    url(r'^register/$', views.UserRegistrationView.as_view(), name="register"),
+    url(r'^reset-password/$', view=views.PasswordResetView.as_view(), name="reset-password"),
+    url(r'^reset-password/confirm/$', views.PasswordResetConfirmView.as_view(), name="reset-password-confirm"),
+
+    url(r'^user/profile/$', views.UserProfileView.as_view(), name="profile"),
+
+]

demo/project/accounts/urls.py

@@ -0,0 +1,77 @@
+from django.shortcuts import get_object_or_404
+from django.views.generic.base import TemplateView
+from rest_framework import parsers, renderers, generics, status
+from rest_framework.authtoken.models import Token
+from rest_framework.authtoken.serializers import AuthTokenSerializer
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from project.accounts.models import User
+from project.accounts.serializers import (
+    UserRegistrationSerializer, UserProfileSerializer, ResetPasswordSerializer
+)
+
+
+class TestView(TemplateView):
+    """
+    This view should not be included in DRF Docs.
+    """
+    template_name = "a_test.html"
+
+
+class LoginView(APIView):
+
+    throttle_classes = ()
+    permission_classes = ()
+    parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,)
+    renderer_classes = (renderers.JSONRenderer,)
+    serializer_class = AuthTokenSerializer
+
+    def post(self, request):
+        serializer = self.serializer_class(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        user = serializer.validated_data['user']
+        token, created = Token.objects.get_or_create(user=user)
+        return Response({'token': token.key})
+
+
+class UserRegistrationView(generics.CreateAPIView):
+
+    permission_classes = (AllowAny,)
+    serializer_class = UserRegistrationSerializer
+
+
+class UserProfileView(generics.RetrieveUpdateAPIView):
+
+    serializer_class = UserProfileSerializer
+
+    def get_object(self):
+        return self.request.user
+
+
+class PasswordResetView(APIView):
+
+    permission_classes = (AllowAny,)
+    queryset = User.objects.all()
+
+    def get_object(self):
+        email = self.request.data.get('email')
+        obj = get_object_or_404(self.queryset, email=email)
+        return obj
+
+    def post(self, request, *args, **kwargs):
+        user = self.get_object()
+        user.send_reset_password_email()
+        return Response({}, status=status.HTTP_200_OK)
+
+
+class PasswordResetConfirmView(APIView):
+
+    permission_classes = (AllowAny,)
+    serializer_class = ResetPasswordSerializer
+
+    def post(self, request, *args, **kwargs):
+        serializer = ResetPasswordSerializer(data=request.data)
+        if not serializer.is_valid():
+            return Response({'errors': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+        return Response({"msg": "Password updated successfully."}, status=status.HTTP_200_OK)

demo/project/accounts/views.py

@@ -0,0 +1,42 @@
+import uuid
+from django.db import models
+from project.accounts.models import User
+
+
+class Organisation(models.Model):
+
+    class Meta:
+        verbose_name_plural = "Organisations"
+        ordering = ['name']
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    created = models.DateTimeField(auto_now_add=True)
+    modified = models.DateTimeField(auto_now=True)
+
+    name = models.CharField(unique=True, max_length=100)
+    slug = models.SlugField(unique=True)
+    members = models.ManyToManyField(User, through='Membership', through_fields=('organisation', 'user'))
+
+    is_active = models.BooleanField(default=False)
+
+    def __str__(self):
+        return self.name
+
+
+class Membership(models.Model):
+
+    class Meta:
+        unique_together = ("organisation", "user")
+
+    MEMBER_ROLES = (
+        ("ADMIN", "Admin"),
+        ("USER", "User")
+    )
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    joined = models.DateTimeField(auto_now_add=True)
+
+    organisation = models.ForeignKey(Organisation)
+    user = models.ForeignKey(User)
+    role = models.CharField(choices=MEMBER_ROLES, max_length=20, default="USER")
+    is_owner = models.BooleanField(default=False)

demo/project/organisations/__init__.py

@@ -0,0 +1,29 @@
+from rest_framework import serializers
+from project.organisations.models import Organisation, Membership
+from project.accounts.serializers import UserProfileSerializer
+
+
+class CreateOrganisationSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Organisation
+        fields = ('name', 'slug',)
+
+
+class OrganisationMembersSerializer(serializers.ModelSerializer):
+    user = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Membership
+        fields = ('joined', 'user', 'is_owner', 'role')
+
+    def get_user(self, obj):
+        serializer = UserProfileSerializer(obj.user)
+        return serializer.data
+
+
+class OrganisationDetailSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Organisation
+        fields = ('name', 'slug', 'is_active')

demo/project/organisations/models.py

@@ -0,0 +1,11 @@
+from django.conf.urls import url
+from project.organisations import views
+
+
+urlpatterns = [
+
+    url(r'^create/$', view=views.CreateOrganisationView.as_view(), name="create"),
+    url(r'^(?P<slug>[\w-]+)/members/$', view=views.OrganisationMembersView.as_view(), name="members"),
+    url(r'^(?P<slug>[\w-]+)/leave/$', view=views.LeaveOrganisationView.as_view(), name="leave")
+
+]

demo/project/organisations/serializers.py

@@ -0,0 +1,31 @@
+from rest_framework import generics, status
+from rest_framework.response import Response
+from project.organisations.models import Organisation, Membership
+from project.organisations.serializers import (
+    CreateOrganisationSerializer, OrganisationMembersSerializer
+)
+
+
+class CreateOrganisationView(generics.CreateAPIView):
+
+    serializer_class = CreateOrganisationSerializer
+
+
+class OrganisationMembersView(generics.ListAPIView):
+
+    serializer_class = OrganisationMembersSerializer
+
+    def get_queryset(self):
+        organisation = Organisation.objects.order_by('?').first()
+        return Membership.objects.filter(organisation=organisation)
+
+
+class LeaveOrganisationView(generics.DestroyAPIView):
+
+    def get_object(self):
+        return Membership.objects.order_by('?').first()
+
+    def delete(self, request, *args, **kwargs):
+        instance = self.get_object()
+        self.perform_destroy(instance)
+        return Response(status=status.HTTP_204_NO_CONTENT)