users_views.py

import json
from base64 import b64decode

#REST Framework
from rest_framework import viewsets, status, serializers
from serializers import UserSerializer, CustomerDetailsSerializer
from rest_framework.response import Response
from rest_framework.decorators import api_view


# Django packages
from django.shortcuts import render
from django.core.exceptions import ObjectDoesNotExist
from django.views.generic import View
from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.views.generic.list import ListView
from django.views.decorators.csrf import csrf_exempt
from django.http import HttpResponse, JsonResponse
from django.core import serializers
from django.core.serializers.json import DjangoJSONEncoder
from django.http import HttpResponseBadRequest
from django.db import connection, transaction
from django.core.files.base import ContentFile
from django.utils.decorators import method_decorator
from django.views.decorators.http import require_http_methods

#from django.contrib.auth.decorators import never_cache



#Auth and register
from django.contrib.auth import authenticate, login as django_login, logout as django_logout
from forms.register import RegistrationFormCustomer, RegistrationFormDriver, RegistrationFormCustomerDetails, RegistrationFormDriverDetails
from forms.authenticate import AuthenticationForm
from forms.forms import DriverDetailsChangeForm, CustomerDetailsChangeForm
from backends import EmailAuthBackend
from debtcollector.models import DebtTable

#logging
import logging
l = logging.getLogger('django.request')
l2 = logging.getLogger('default')
from models import CustomUser, CustomerDetails, DriverDetails
from itertools import chain

#Decorators

# Create your views here.


"""
REST classes

"""

#class UserViewSet(viewsets.ModelViewSet):


class CreationView(View):

	"""
	The CreationView.

	Handles views related to creation of users. Through this interface, one can create either a customer or a driver.

	There is currently no use for the method create_driver, as these are created through the admin page.

	For each User object, a separate table is used to maintain additional non-trivial data about the user. This is a security measure, as the user object itself might be vulnerable.



	TODO:
		Remove csrf_exempt, as cookies have been implemented on the client.


	Attributes:
		customerForm (:obj: RegistrationFormCustomer): The form that validates Customer data.
		customerDetailsForm (:obj: RegistrationFormCustomerDetails) : The form that validates Customer Details data.

		driverForm (:obj: RegistrationFormDriver): The form that validates Driver data.
		driverDetailsForm (:obj: RegistrationFormDriverDetails): The form that validates Driver Details data.

	"""

	customerForm = RegistrationFormCustomer
	customerDetailsForm = RegistrationFormCustomerDetails
	driverForm = RegistrationFormDriver
	driverDetailsForm = RegistrationFormDriverDetails

	#@require_http_methods(['GET', 'POST',])
	def dispatch(self, *args, **kwargs):
		return super(CreationView, self).dispatch(*args, **kwargs)

	@csrf_exempt
	def create_customer(self, request):

		"""Creates a customer details object if the data provided is valid.

		Args:
			request (:obj: HttpRequest): The request object generated by the HttpRequest module. Contains headers, session data and payload(amongst others)

		Returns:
			HttpResponse(user, content_type="application/json") if successful.
			HttpResponseBadRequest("Customer details data not saved.") if details form is invalid.
			HttpResponseBadRequest("Customer form is invalid.") if user form is invalid.


		"""

		json_data = json.loads(request.body)

		form = self.customerForm(json_data)
		serialized = UserSerializer(data=json_data)
		if form.is_valid():
			user = form.save()
			detailsForm = RegistrationFormCustomerDetails(json_data)
			if detailsForm.is_valid():
				serializedDetails = CustomerDetailsSerializer(json_data)
				cd = CustomerDetails.objects.create_customer_details(user=user,
					phone=json_data.get('phone'),
					facebookurl=json_data.get('facebookurl'),
					nationality=json_data.get('nationality'))
				cd.save()

				print "SERIALIZED USER"
			else:
				return JsonResponse(CustomerDetailsSerializer(instance=serializedDetails), status=status.HTTP_201_CREATED)

			return JsonResponse(UserSerializer(instance=user).data, status=status.HTTP_201_CREATED)

		return Response(serialized.initial_data, status=status.HTTP_400_BAD_REQUEST)

	def create_driver(self, request):

		"""Not used"""

		json_data = json.loads(request.body)

		form = self.driverForm(json_data)

		if form.is_valid():
			user = form.save()
			detailsForm = RegistrationFormDriverDetails(json_data)

			if detailsForm.is_valid():
				dd = DriverDetails.objects.create_driver_details(user=user, phone=json_data.get('phone'), facebookurl=json_data.get('facebookurl'))
				dd.save()
				driver_name = user.firstname + " " + user.lastname
				debt = DebtTable(driver = dd, debt = 0.0, driver_email=user.email, driver_name=driver_name)
				debt.save()
			else:
				return HttpResponseBadRequest("Driver details data not saved.")
			return HttpResponse(user, content_type="application/json")
		return HttpResponseBadRequest("Driver form is invalid.")

	@csrf_exempt
	def post(self, request, *args, **kwargs):
		if request.path == '/create_customer':
			return self.create_customer(request)
		elif request.path == '/create_driver':
			return self.create_driver(request)

		return HttpResponseBadRequest("Invalid URL")

class AuthView(View):

	def login(self, request):

		"""Logs the user in.

		The response of this method is subject to rework and will return responses based on standards in the REST framework

		Args:
			request (:obj: HttpRequest): The request object generated by the HttpRequest module. Contains headers, session data and payload(amongst others)

		Returns:
			HttpResponse("User is now logged in.") if successful. As a security measure, note that a user has to be flagged as is_active == True in order to be logged in.


		"""

		json_data = json.loads(request.body)

		username = json_data.get('email')
		password = json_data.get('password')
		form = AuthenticationForm(json_data)


		if form.is_valid():
			try:
				user = authenticate(email=username, password=password)
				if user.is_authenticated():
					request.session['user_email'] = username
					if user.is_active:
						django_login(request, user)
						return HttpResponse("User is now logged in.")
					else:
						return HttpResponse("Inactive user.")
				else:
					return HttpResponse("User is None.(views.login())")
			except Exception:
				return HttpResponseBadRequest("Login failed.")

		return HttpResponseBadRequest("User form invalid")

	def logout(self, request):

		json_data = json.loads(request.body)

		user = request.user

		if user.user_type == 'D':
			driver_instance = DriverDetails.objects.get(user_instance=user)

		try:
			django_logout(request)
			if user.user_type == 'D':
				driver_instance.available=False

			return HttpResponse("User logged out.")
		except Exception, e:
			raise e

		return HttpResponseBadRequest

	def post(self, request, *args, **kwargs):

		if request.path == '/login':
			return self.login(request)
		elif request.path == '/logout':
			return self.logout(request)
		return Http404("url does not exist")

class DetailsView(View):

	def add_profile_pic(self, request, details_obj):

		"""Saves a profile picture to target details_obj

		Args:
			request (:obj: HttpRequest): The request object generated by the HttpRequest module. Contains headers, session data and payload(amongst others)
			details_obj (:obj: CustomerDetails || :obj: DriverDetails): The details object connected to the user.

		Returns:
			HttpResponse("Profile picture saved") if successful
			HttpResponseBadRequest("An expcetion was caught: Profile Picture not saved.", error_message) otherwise.

		"""

		try:
			json_data = json.loads(request.body)

			base64raw = json_data.get('profile_pic')
			image_name = str(request.user.id) + "_profile.png"
			image_data = ContentFile(b64decode(base64raw), image_name)

			details_obj.profile_pic.save(image_name, image_data, save=True)

			return HttpResponse("Profile picture saved.")

		except Exception, e:
			return HttpResponseBadRequest("An expcetion was caught: Profile Picture not saved.", e)

	def get_profile_pic(self, request):

		"""Fetches the profile picture for the specific user.

		Args:
			request (:obj: HttpRequest): The request object generated by the HttpRequest module. Contains headers, session data and payload(amongst others)

		Returns:
			JsonResponse(:json: ContentFile): A JsonResponse containing the base64 encoded profile picture wrapped in a File upon success
			HttpResponseBadRequest("Something went wrong when fetching Profile Picture.") otherwise.
		TODO:
			Add support for multiple pictures per user.
		 """

		json_data = json.loads(request.body)

		user = CustomUser.objects.get(email=json.data.get("email"))
		user_type = json_data.get("user_type")

		if user_type == "D":
			details_obj = DriverDetails.objects.get(user_instance=user)
		elif user_type == "C":
			details_obj = CustomerDetails.objects.get(user_instance=user)
		else:
			details_obj = None
		try:
			image_data = ContentFile(b64encode(details_obj.profile_pic.file.read()))
			image_dict = json.dumps({"b64_img" : image_data})
			return JsonResponse(image_dict)
		except Exception as e:
			return HttpResponseBadRequest("Something went wrong when fetching Profile Picture.")


	def get_driver_details(self, request):

		"""
			Rewrite to use request.user?

		"""

		try:

			driver_email = request.session['trip_driver_email']

			user_instance = CustomUser.objects.get(email=driver_email)

			dd = DriverDetails.objects.get(user_instance=user_instance)
			return HttpResponse(serializers.serialize("json", [user_instance, dd]))
		except Exception, e:
			return HttpResponse("Driver not found")

		return HttpResponse("Driver not found")
	def available(self, request):

		user_instance = CustomUser.objects.get(email=request.GET['email'])

		dd = DriverDetails.objects.get(user_instance=user_instance)

		return dd.available

	def post(self, request):

		if request.user.is_authenticated():

			if request.path == '/get_driver_details':
				return self.get_driver_details(request)
			elif request.path =='/add_profile_pic':
				if request.user.user_type == 'C':
					return self.add_profile_pic(request, CustomerDetails.objects.get(user_instance=request.user))
				elif request.user.user_type == 'D':
					return self.add_profile_pic(request, DriverDetails.objects.get(user_instance=request.user))
				else:
					return HttpResponseBadRequest("Invalid user type")
			elif request.path =='/get_profile_pic':
				return self.get_profile_pic(request)

			return HttpResponseBadRequest("Bad url")
		else:
			return HttpResponseBadRequest("User not authenticated.")

	def get(self, request):

		if request.user.is_authenticated():

			if request.path == '/available/':
				return HttpResponse(self.available(request))
			return HttpResponseBadRequest("Bad URL")
		else:
			return HttpResponseBadRequest("User not authenticated")

class CustomerAlreadyExistsException(Exception):

	pass