Complete Working App from boilerplate

Author: sshishov

.bowerrc

@@ -0,0 +1,3 @@
+{
+	"directory": "static/bower_components"
+}

.buildpacks

@@ -0,0 +1,2 @@
+https://github.com/heroku/heroku-buildpack-python.git
+https://github.com/heroku/heroku-buildpack-nodejs.git

.gitignore

@@ -0,0 +1,24 @@
+# Python compiled byte code
+*.pyc
+
+# SQLite3 database
+*.sqlite3
+
+# Node modules
+node_modules/
+
+# Bower components
+static/bower_components/
+
+# Uglified JavaScript
+dist/
+
+# Staticfiles
+staticfiles/
+
+# PyCharm
+.idea
+
+# npm
+npm-debug.log
+

Procfile

@@ -0,0 +1 @@
+web: gunicorn django_and_angular.wsgi --log-file -

README.md

@@ -0,0 +1,19 @@
+# thinkster-django-angular-boilerplate
+
+## Installation
+
+*NOTE: Requires [virtualenv](http://virtualenv.readthedocs.org/en/latest/),
+[virtualenvwrapper](http://virtualenvwrapper.readthedocs.org/en/latest/) and
+[Node.js](http://nodejs.org/).*
+
+* Fork this repository.
+* `$ git clone [email protected]:<your username>/thinkster-django-angular-boilerplate.git`
+* `$ mkvirtualenv thinkster-djangular`
+* `$ cd thinkster-django-angular-boilerplate/`
+* `$ pip install -r requirements.txt`
+* `$ npm install -g bower`
+* `$ npm install`
+* `$ bower install`
+* `$ python manage.py migrate`
+* `$ python manage.py runserver`
+

authentication/__init__.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

authentication/admin.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Account',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('last_login', models.DateTimeField(default=django.utils.timezone.now, verbose_name='last login')),
+                ('email', models.EmailField(unique=True, max_length=75)),
+                ('username', models.CharField(unique=True, max_length=40)),
+                ('first_name', models.CharField(max_length=40, blank=True)),
+                ('last_name', models.CharField(max_length=40, blank=True)),
+                ('tagline', models.CharField(max_length=140, blank=True)),
+                ('is_admin', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                'abstract': False,
+            },
+            bases=(models.Model,),
+        ),
+    ]

authentication/migrations/0001_initial.py

@@ -0,0 +1,56 @@
+from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
+from django.db import models
+
+
+class AccountManager(BaseUserManager):
+    def create_user(self, email, password=None, **kwargs):
+        if not email:
+            raise ValueError('Users must have a valid email address.')
+
+        if not kwargs.get('username'):
+            raise ValueError('Users must have a valid username.')
+
+        account = self.model(
+            email=self.normalize_email(email), username=kwargs.get('username')
+        )
+
+        account.set_password(password)
+        account.save()
+
+        return account
+
+    def create_superuser(self, email, password, **kwargs):
+        account = self.create_user(email, password, **kwargs)
+
+        account.is_admin = True
+        account.save()
+
+        return account
+
+
+class Account(AbstractBaseUser):
+    email = models.EmailField(unique=True)
+    username = models.CharField(max_length=40, unique=True)
+
+    first_name = models.CharField(max_length=40, blank=True)
+    last_name = models.CharField(max_length=40, blank=True)
+    tagline = models.CharField(max_length=140, blank=True)
+
+    is_admin = models.BooleanField(default=False)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    objects = AccountManager()
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['username']
+
+    def __unicode__(self):
+        return self.email
+
+    def get_full_name(self):
+        return ' '.join([self.first_name, self.last_name])
+
+    def get_short_name(self):
+        return self.first_name

authentication/migrations/__init__.py

@@ -0,0 +1,8 @@
+from rest_framework import permissions
+
+
+class IsAccountOwner(permissions.BasePermission):
+    def has_object_permission(self, request, view, account):
+        if request.user:
+            return account == request.user
+        return False

authentication/models.py

@@ -0,0 +1,37 @@
+from django.contrib.auth import update_session_auth_hash
+
+from rest_framework import serializers
+
+from authentication.models import Account
+
+
+class AccountSerializer(serializers.ModelSerializer):
+    password = serializers.CharField(write_only=True, required=False)
+    confirm_password = serializers.CharField(write_only=True, required=False)
+
+    class Meta:
+        model = Account
+        fields = ('id', 'email', 'username', 'created_at', 'updated_at',
+                  'first_name', 'last_name', 'tagline', 'password',
+                  'confirm_password',)
+        read_only_fields = ('created_at', 'updated_at',)
+
+        def create(self, validated_data):
+            return Account.objects.create(**validated_data)
+
+        def update(self, instance, validated_data):
+            instance.username = validated_data.get('username', instance.username)
+            instance.tagline = validated_data.get('tagline', instance.tagline)
+
+            instance.save()
+
+            password = validated_data.get('password', None)
+            confirm_password = validated_data.get('confirm_password', None)
+
+            if password and confirm_password and password == confirm_password:
+                instance.set_password(password)
+                instance.save()
+
+            update_session_auth_hash(self.context.get('request'), instance)
+
+            return instance

authentication/permissions.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

authentication/serializers.py

@@ -0,0 +1,75 @@
+import json
+
+from django.contrib.auth import authenticate, login, logout
+
+from rest_framework import permissions, viewsets, status, views
+from rest_framework.response import Response
+
+from authentication.models import Account
+from authentication.permissions import IsAccountOwner
+from authentication.serializers import AccountSerializer
+
+
+class AccountViewSet(viewsets.ModelViewSet):
+    lookup_field = 'username'
+    queryset = Account.objects.all()
+    serializer_class = AccountSerializer
+
+    def get_permissions(self):
+        if self.request.method in permissions.SAFE_METHODS:
+            return (permissions.AllowAny(),)
+
+        if self.request.method == 'POST':
+            return (permissions.AllowAny(),)
+
+        return (permissions.IsAuthenticated(), IsAccountOwner(),)
+
+    def create(self, request):
+        serializer = self.serializer_class(data=request.data)
+
+        if serializer.is_valid():
+            Account.objects.create_user(**serializer.validated_data)
+
+            return Response(serializer.validated_data, status=status.HTTP_201_CREATED)
+
+        return Response({
+            'status': 'Bad request',
+            'message': 'Account could not be created with received data.'
+        }, status=status.HTTP_400_BAD_REQUEST)
+
+
+class LoginView(views.APIView):
+    def post(self, request, format=None):
+        data = json.loads(request.body)
+
+        email = data.get('email', None)
+        password = data.get('password', None)
+
+        account = authenticate(email=email, password=password)
+
+        if account is not None:
+            if account.is_active:
+                login(request, account)
+
+                serialized = AccountSerializer(account)
+
+                return Response(serialized.data)
+            else:
+                return Response({
+                    'status': 'Unauthorized',
+                    'message': 'This account has been disabled.'
+                }, status=status.HTTP_401_UNAUTHORIZED)
+        else:
+            return Response({
+                'status': 'Unauthorized',
+                'message': 'Username/password combination invalid.'
+            }, status=status.HTTP_401_UNAUTHORIZED)
+
+
+class LogoutView(views.APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+
+    def post(self, request, format=None):
+        logout(request)
+
+        return Response({}, status=status.HTTP_204_NO_CONTENT)

authentication/tests.py

@@ -0,0 +1,23 @@
+{
+  "name": "django_and_angular",
+  "version": "0.0.0",
+  "homepage": "https://github.com/sshishov/DjangoAndAngular",
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ],
+  "dependencies": {
+    "angular": "~1.3.1",
+    "angular-route": "~1.3.1",
+    "angular-cookies": "~1.3.1",
+    "bootstrap": "~3.3.0",
+    "bootstrap-material-design": "~0.1.5",
+    "jquery": "~2.1.1",
+    "ngDialog": "~0.3.3",
+    "underscore": "~1.7.0"
+  }
+}