models.py

from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.contrib.auth.models import AbstractUser
from django.db import models

GENDER = (('F','Female'),('M','Male'))

# Create your models here.

class Proffession(models.Model):
    create_by = models.ForeignKey(User, verbose_name='Created By')
    name = models.CharField(verbose_name='Proffession Name', max_length=255)
    created_date = models.DateTimeField(auto_now_add=True, null=True, blank=True)
    is_active = models.BooleanField(default=True, verbose_name='Is Active')

    class Meta:
        verbose_name = "Proffession"
        verbose_name_plural = "Proffessions"

    def __str__(self):
        return self.name +" : "+ str(self.created_date)


class ArtistToken(User):
    phone_number = models.CharField(max_length=12,verbose_name='Phone Number', unique=True)
    api_token = models.CharField(max_length=255, verbose_name='API token', null=True, blank=True)
    key_generated = models.DateTimeField(auto_now_add=True, verbose_name='Key Generated Date')
    is_verifed = models.BooleanField(default=True)

    class Meta:
        verbose_name = "ArtistToken"
        verbose_name_plural = "ArtistTokens"

    def __str__(self):
        return self.phone_number

    

class Artist(models.Model):
    artist_token = models.OneToOneField(ArtistToken, related_name='artist_token')
    profile_image = models.URLField(verbose_name ="Image",null=True,blank=True)
    joined_date = models.DateTimeField(auto_now_add=True, verbose_name='Date JoinedS')
    full_name = models.CharField(max_length=255, verbose_name='Full Name', null=True, blank=True)
    email = models.EmailField(verbose_name='Email', null=True, blank=True)
    location =  models.CharField(max_length=255, verbose_name= "Location", null=True, blank=True)
    p_email = models.EmailField(verbose_name='Personal Email', null=True, blank=True)
    p_location = models.CharField(max_length=255, verbose_name= "Persoanl Location", null=True, blank=True)
    dob = models.DateField (verbose_name='Date Of Birth', null=True, blank=True)
    height = models.CharField(verbose_name='Height', max_length=255, null=True, blank=True)
    gender = models.CharField(choices=GENDER,max_length=1,verbose_name='Gender')
    languages = models.TextField(verbose_name='Languages',null=True, blank=True)
    proffession_field = models.ForeignKey(Proffession, verbose_name='Proffession', related_name='artist_proffession')
    is_verifed = models.BooleanField(default=True, verbose_name='Is Active')
    is_completed = models.BooleanField(default=False, verbose_name='Completed or Not ?')
    is_first_login = models.BooleanField(default=False, verbose_name='First Login ?')

    class Meta:
        verbose_name = "Artist"
        verbose_name_plural = "Artists"

    def __str__(self):
        return str(self.full_name) + " : " + str(self.joined_date)

    def get_profile_image(self):
        if self.profile_image:
            return self.profile_image.url
        else:
            return None

class Followers(models.Model):
    artist = models.ForeignKey(Artist, related_name='following')
    follower = models.ForeignKey(Artist, related_name='followers')   
    date_created = models.DateTimeField(auto_now_add=True, verbose_name='Date Created')
    date_updated = models.DateTimeField(null=True, blank=True)
    is_follow =  models.BooleanField(default=True, verbose_name='Followed')

    class Meta:
        verbose_name = "Followers"
        verbose_name_plural = "Followers"

    def __str__(self):
        return str(self.id)

class UserContent(models.Model):
    artist = models.ForeignKey(Artist, verbose_name='artist', related_name='usercontent')
    date_created = models.DateTimeField(auto_now_add=True, null=True, blank=True)

class VideoContent(models.Model):
    artist = models.ForeignKey(Artist, related_name='videocontents', null=True, blank=True)
    video_url = models.URLField(verbose_name='Video Url')
    video_desc = models.TextField(verbose_name='Video Description', null=True, blank=True)
    date_created = models.DateTimeField(auto_now_add=True, verbose_name='Content Created')
    active = models.BooleanField(default=True, verbose_name='Active ?')
    class Meta:
        verbose_name = "VideoContent"
        verbose_name_plural = "VideoContents"

    def __str__(self):
        self.artist.full_name + " : " + str(self.date_created)

class AudioContent(models.Model):
    artist = models.ForeignKey(Artist, related_name='audiocontents', null=True, blank=True)
    audio_url = models.URLField(verbose_name='Audio Url')
    audio_desc = models.TextField(verbose_name='Audio Description', null=True, blank=True)
    date_created = models.DateTimeField(auto_now_add=True, verbose_name='Content Created')
    active = models.BooleanField(default=True, verbose_name='Active ?')
    class Meta:
        verbose_name = "AudioContent"
        verbose_name_plural = "AudioContents"

    def __str__(self):
        self.artist.full_name + " : " + str(self.date_created)

class ImageContent(models.Model):
    artist = models.ForeignKey(Artist, related_name='imagecontents', null=True, blank=True)
    image_file = models.URLField(verbose_name ="Image",null=True,blank=True)
    video_desc = models.TextField(verbose_name='Imgae Description', null=True, blank=True)
    date_created = models.DateTimeField(auto_now_add=True, verbose_name='Content Created')
    active = models.BooleanField(default=True, verbose_name='Active ?')

    class Meta:
        verbose_name = "ImageContent"
        verbose_name_plural = "ImageContents"
# # 
#     def __str__(self):
#         self.date_created


class ChatMessage(models.Model):
    sender   = models.ForeignKey(Artist, related_name = 'sendermessages')
    receiver = models.ForeignKey(Artist, related_name = 'receivemessages')
    message  = models.CharField(max_length = 200)
    received_at = models.DateTimeField(auto_now_add = True)
    is_read = models.BooleanField(default=False)

    class Meta:
        verbose_name = "ChatMessage"
        verbose_name_plural = "ChatMessages"

serializer.py

from rest_framework import serializers
from django.conf import settings
from crafter.apps.staffs.models import (Artist, ArtistToken, Proffession,Followers,ChatMessage,
    VideoContent,AudioContent,ImageContent)
from crafter.apps.project.models import (ProjectType,Project,ProjectMembers, UserRequest)
from crafter.apps.general.models import (Notifications,)

class ProfessionSerilizer(serializers.ModelSerializer):
    class Meta:
       model = Proffession
       fields = ('id', 'name')
class ArtisTokenSerilizer(serializers.ModelSerializer):
    class Meta:
       model = ArtistToken
       fields = ('phone_number')
class ArtistSerializer(serializers.ModelSerializer):
    gender = serializers.SerializerMethodField()
    class Meta:
       model = Artist
       fields = '__all__'
    def get_gender(self, obj):
        return obj.get_gender_display()
class FollowingSerializer(serializers.ModelSerializer):
    follower = serializers.SerializerMethodField()
    class Meta:
       model = Followers
       fields = ('follower', 'date_created', 'date_updated', 'is_follow')

    def get_follower(self, obj):
        try:
            follower = Artist.objects.get(id= obj.follower.id)
            return settings.SITE_URL+'/api/v1/artist/{0}/'.format(follower.id)
        except:
            pass
class FollowersSerializer(serializers.ModelSerializer):
    artist = serializers.SerializerMethodField()
    class Meta:
       model = Followers
       fields = ('artist', 'date_created', 'date_updated', 'is_follow')

    def get_artist(self, obj):
        try:
            artist = Artist.objects.get(id=obj.artist.id)
            return settings.SITE_URL+'/api/v1/artist/{0}/'.format(artist.id)
        except:
            pass
class ChatMessageSerializer(serializers.ModelSerializer):
    sender = serializers.SerializerMethodField()
    sender_name = serializers.SerializerMethodField()
    class Meta:
        model  = ChatMessage
        fields = '__all__'
    def get_sender(self,obj):
        return settings.SITE_URL+'/api/v1/artist/{0}/'.format(obj.sender.id)
    def get_sender_name(self, obj):
        return obj.sender.full_name if obj.sender.full_name else Noner
class SendMessageSerializer(serializers.ModelSerializer):
    receiver = serializers.SerializerMethodField()
    receiver_name = serializers.SerializerMethodField()
    message_detail = serializers.SerializerMethodField()
    class Meta:
        model = ChatMessage
        fields = ('id','receiver_name','receiver','message','message_detail','received_at', 'is_read')

    def get_receiver(self,obj):
        return settings.SITE_URL+'/api/v1/artist/{0}/'.format(obj.receiver.id)
    def get_receiver_name(self, obj):
        return obj.receiver.full_name if obj.receiver.full_name else None
    def get_message_detail(self,obj):
        return settings.SITE_URL+'/api/v1/messages/'+str(obj.id) +'/'
class ReciveMessageSerializer(serializers.ModelSerializer):
    sender = serializers.SerializerMethodField()
    sender_name = serializers.SerializerMethodField()
    message_detail = serializers.SerializerMethodField()
    class Meta:
        model = ChatMessage
        fields = ('id','receiver_name','receiver','message','message_detail','received_at', 'is_read')

    def get_receiver(self,obj):
        return settings.SITE_URL+'/api/v1/artist/{0}/'.format(obj.sender.id)
    def get_receiver_name(self, obj):
        return obj.sender.full_name if obj.sender.full_name else None
    def get_message_detail(self,obj):
        return settings.SITE_URL+'/api/v1/messages/'+str(obj.id) +'/'

class ConversationMessageSerializer(serializers.ModelSerializer):
    class Meta:
        model = ChatMessage
        fields = '__all__'
class ProjectTypeSerializer(serializers.ModelSerializer):
    class Meta:
        model = ProjectType
        fields = '__all__'

class ProjectSerializer(serializers.ModelSerializer):
    class Meta:
       model = Project
       fields = '__all__'

class UserRequestSerializer(serializers.ModelSerializer):
    class Meta:
       model = UserRequest
       fields = '__all__'
class ImageContentSerializer(serializers.ModelSerializer):
    class Meta:
        model = ImageContent
        fields = '__all__'

class VideoContentSerializer(serializers.ModelSerializer):
    class Meta:
        model = VideoContent
        fields = '__all__'

class AudioContentSerializer(serializers.ModelSerializer):
    class Meta:
        model = AudioContent
        fields = '__all__'


class NotificationSerializer(serializers.ModelSerializer):
    class Meta:
        model = Notifications
        fields = '__all__'

views.py

from django.shortcuts import render
from rest_framework import viewsets
from crafter.apps.response import JSONResponse
from crafter.apps.staffs.models import (Artist, ArtistToken, Proffession, Followers, ChatMessage,
    VideoContent, AudioContent, ImageContent)
from crafter.apps.general.models import Notifications
from .serializers import( ArtistSerializer, ArtisTokenSerilizer, ProfessionSerilizer, FollowersSerializer,
            FollowingSerializer, ChatMessageSerializer, SendMessageSerializer, ConversationMessageSerializer,
            ProjectTypeSerializer, ProjectSerializer, UserRequestSerializer, ImageContentSerializer, 
            VideoContentSerializer,AudioContentSerializer, NotificationSerializer)
from crafter.apps.project.models import (ProjectType, Project, ProjectMembers, UserRequest)
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.views import APIView
from rest_framework import generics
from rest_framework import renderers
from rest_framework.parsers import JSONParser, FileUploadParser, MultiPartParser, FormParser
from rest_framework.decorators import api_view
from django.views.decorators.csrf import csrf_exempt
from django.utils.crypto import get_random_string
from django.contrib.auth import authenticate
from rest_framework.authtoken.models import Token
import json, datetime
from django.conf import settings
from django.db.models import Q
from django.shortcuts import get_object_or_404
from rest_framework.exceptions import APIException
from rest_framework import status
from rest_framework.views import exception_handler
from boto.s3.connection import S3Connection
from boto.s3.key import Key
from django.conf import settings
import mimetypes
from rest_framework import exceptions


def VerificateAUTHToken(request):
    if not request.META.has_key('HTTP_TOKEN'):
        return False
    token = request.META.get('HTTP_TOKEN')
    model = Token
    try:
        token = model.objects.select_related('user').get(key=token)
    except model.DoesNotExist:
        raise exceptions.AuthenticationFailed(_('Invalid token.'))
    if not token.user.is_active:
        raise exceptions.AuthenticationFailed(_('User inactive or deleted.'))
    return True
    


def api_500_handler(exception, context):
    response = exception_handler(exception, context)
    print "Fdfdf"
    try:
        detail = response.data['detail']
    except AttributeError:
        detail = exception.message
    response = HttpResponse(
        json.dumps({'detail': detail}),
        content_type="application/json", status=400
    )
    return response

@csrf_exempt
def check_auth(request):
    print "FDFSDDF"
    csrf_dict = {}
    csrf_dict.update(csrf(request))
    print "FSDF"

class error_404page(APIView):

    def get(self, request, *args, **kwargs):
        return Response("fdf")

# Create your views here.

def clean_client_phone(client_phone):
    str(client_phone)
    try:
        if long(client_phone) and type(client_phone)==int:
            min_length = 10
            max_length = 13
            ph_length = str(client_phone)
            if len(ph_length) < min_length or len(ph_length) > max_length:
                raise ValidationError('Phone number length not valid')
    except (ValueError, TypeError):
        return False
    return True


class ArtistAuth(APIView):
    def post(self,request, format=None):
        data =  request.data
        if data.has_key('phone_number'):
            if clean_client_phone(client_phone=data.get('phone_number')):
                phone_number = data.get('phone_number')
                if ArtistToken.objects.filter(phone_number= phone_number):
                    user = ArtistToken.objects.get(phone_number=phone_number)
                    if Token.objects.filter(user = user):
                        token = Token.objects.get(user = user)
                        token.delete()
                    else:
                        pass
                else:
                    password = 'crafter_'+str(phone_number)
                    user = ArtistToken.objects.create(phone_number=phone_number, username=phone_number,\
                            password= password)
                token = Token.objects.create(user= user)
                if authenticate(username=user.username):
                    return JSONResponse({'status':"success", "message":"Successfuly logined", "token":token.key})
                else:
                    return JSONResponse({'status':"error", "message":"Something went wrong"})
            else:
                return JSONResponse({'status':"error", "message":"Phone Number validation error"})
        else:
            return JSONResponse({'status':"error", "message":"Phone Number is missing"})


class ArtistLogout(APIView):
    def post(self,request, format=None):
        if request.META.has_key('HTTP_AUTHORIZATION'):
            header = request.META.get('HTTP_AUTHORIZATION').split()[1]
            try:
                token = Token.objects.get(key=str(header))
                user = ArtistToken.objects.get(id=token.user.id)
            except Token.DoesNotExist:
                return JSONResponse({'status':"error", "message":"Permission Denied"})
            else:
                token.delete()
            return JSONResponse({'status':"success", "message":"Successfully logout"})
        else:
            return JSONResponse({'status':"error", "message":"Authentication token is Missing from Header"})

class ProffessionHighlight(generics.GenericAPIView):
    queryset = Proffession.objects.all()
    renderer_classes = (renderers.StaticHTMLRenderer,)

    def get(self, request, *args, **kwargs):
        snippet = self.get_object()
        return Response(snippet.highlighted)



class ProffessionViewSet(viewsets.ModelViewSet):
    queryset = Proffession.objects.all()
    serializer_class = ProfessionSerilizer



class ArtistProfile(APIView):
    parser_classes = (MultiPartParser, FormParser,)

    def get_object(self, pk):
        try:
            return Artist.objects.get(pk=pk)
        except Artist.DoesNotExist:
            raise Http404

    def get(self, request, pk, format=None):
        token_ver = VerificateAUTHToken(request)
        if token_ver:
            artist = self.get_object(pk)
            serializer = ArtistSerializer(artist)
            return JSONResponse(serializer.data)
        else:
            return JSONResponse({'status':"error", "message":"Token veriification error"})

    def post(self, request, pk=None, format=None):
        data = request.data
        # header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        if 
        header = request.META.get('HTTP_TOKEN')
        required_fields = ['name', 'email', 'location', 'height', 'gender',
                           'p_email', 'p_location','dob','proffession']
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field):
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = ArtistToken.objects.get(id=token.user.id)
        except:
            return JSONResponse({'status':"error", "message":"Permission Denied"})
        else:
            proff = Proffession.objects.get(id=data.get('proffession'))
            if pk:
                try:
                    artist = Artist.objects.get(artist_token=user)
                    if data.get('profile_image'):
                        filename = data.get('profile_image').name
                        content = data.get('profile_image').read()
                        conn = S3Connection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
                        bucket = conn.create_bucket("craftermediafiles")
                        mime = mimetypes.guess_type(filename)[0]
                        k = Key(bucket)
                        k.key = filename
                        k.set_metadata("Content-Type", mime)
                        k.set_contents_from_string(content)
                        k.set_acl("public-read")
                        url = "http://craftermediafiles.s3.amazonaws.com/"+str(filename)
                        artist.profile_image = url
                    artist.full_name = data.get('name')
                    artist.email=data.get('email')
                    artist.location=data.get('location')
                    artist.height=data.get('height')
                    artist.gender=data.get('gender')
                    artist.p_email=data.get('p_email')
                    artist.p_location=data.get('p_location')
                    artist.dob=datetime.datetime.strptime(data.get('dob'), "%d-%m-%Y")
                    artist.languages=data.get('languages')
                    artist.proffession_field = proff
                    artist.save()
                    category = 'URC'
                    subject = 'Update account'
                    desc = ' %s Update Account' %(artist.full_name)
                except Artist.DoesNotExist:
                    return JSONResponse({'status':"error", "message":"Permission Denied"})
            else:
                artist = Artist.objects.create(artist_token=user,
                    full_name = data.get('name'), email=data.get('email'), location=data.get('location'),
                    height=data.get('height'), gender=data.get('gender'), p_email=data.get('p_email'), 
                    p_location=data.get('p_location'),
                    dob=datetime.datetime.strptime(data.get('dob'), "%d-%m-%Y"),
                    languages=data.get('languages'), proffession_field = proff)
                if data.get('profile_image'):
                    filename = data.get('profile_image').name
                    content = data.get('profile_image').read()
                    conn = S3Connection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
                    bucket = conn.create_bucket("craftermediafiles")
                    mime = mimetypes.guess_type(filename)[0]
                    k = Key(bucket)
                    k.key = filename
                    k.set_metadata("Content-Type", mime)
                    k.set_contents_from_string(content)
                    k.set_acl("public-read")
                    url = "http://craftermediafiles.s3.amazonaws.com/"+str(filename)
                    artist.profile_image = url            
                artist.save()
                category = 'CRC'
                subject = 'Created Account'
                desc = ' %s New Account registration' %(artist.full_name)
            detail_url = settings.SITE_URL+'/api/v1/artist/{0}/'.format(artist.id)
            notification  = Notifications.objects.create(subject=subject, url=detail_url, category=category, 
                            description=desc)
            notification.save()
            return JSONResponse({'status':"success", "message":"Successfully updated profile",'full_name':artist.full_name, 'detial':detail_url})


class FollowAPI(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    def post(self,request, format=None):
        data = request.data
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        if data.has_key('follower_id') and data.get('follower_id'):
            try:
                token = Token.objects.get(key=str(header))
                user = ArtistToken.objects.get(id=token.user.id)
                follower = ArtistToken.objects.get(id=data['follower_id'])
            except ArtistToken.DoesNotExist:
                return JSONResponse({'status':"error", "message":"Permission Denied"})
            follow = Followers.objects.create(artist=user,follower=follower)
            sender = Artist.objects.get(artist_token=user)
            recver = Artist.objects.get(artist_token=follower)
            category = 'FWD'
            subject = '{0} following {1}'.format(sender.full_name, recver.full_name)
            sender_url = settings.SITE_URL+'/api/v1/artist/{0}/'.format(sender.id)
            recver_url = settings.SITE_URL+'/api/v1/artist/{0}/'.format(recver.id)
            desc = '{0} following {1}'.format(sender_url,recver_url)
            notification  = Notifications.objects.create(subject=subject, category=category, description=desc)
            return JSONResponse({'status':"success", "message":"successfully following {0}".format(recver.full_name)})
        else:
            return JSONResponse({'status':"error", "message":"Missing follower id"})


class FollwoingArtistList(generics.ListAPIView):
    model = Followers
    serializer_class = FollowingSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.following.all()
        return queryset

class FollwersArtistList(generics.ListAPIView):
    model = Followers
    serializer_class = FollowersSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.followers.all()
        return queryset


class FollowAPI(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    def post(self,request, format=None):
        data = request.data
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        if data.has_key('follower_id') and data.get('follower_id'):
            try:
                token = Token.objects.get(key=str(header))
                user = Artist.objects.get(artist_token=token.user)
                follower = Artist.objects.get(id=data['follower_id'])
            except Artist.DoesNotExist:
                return JSONResponse({'status':"error", "message":"Permission Denied"})
            follow = Followers.objects.create(artist=user,follower=follower)
            category = 'FWD'
            subject = '{0} following {1}'.format(user.full_name, follower.full_name)
            sender_url = settings.SITE_URL+'/api/v1/artist/{0}/'.format(user.id)
            recver_url = settings.SITE_URL+'/api/v1/artist/{0}/'.format(follower.id)
            desc = '{0} following {1}'.format(sender_url,recver_url)
            notification  = Notifications.objects.create(subject=subject, category=category, description=desc)
            return JSONResponse({'status':"success", "message":"successfully following {0}".format(follower.full_name)})
        else:
            return JSONResponse({'status':"error", "message":"Missing follower id"})

class PrivateMessageAPI(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def post(self, request, format=None):
        data = request.data
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            sender = Artist.objects.get(artist_token=token.user)
            receiver = Artist.objects.get(id=data.get('reciver_id'))
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        chat = ChatMessage.objects.create(sender=sender, receiver=receiver, message=data.get('message'))
        notification = Notifications()
        notification.sender = sender
        notification.receiver = receiver
        notification.subject = sender.full_name + "send message to you"
        notification.category = 'MGS'
        notification.url = settings.SITE_URL+'/api/v1/messages/'+str(chat.id)+'/'
        notification.description = sender.full_name + "send message to " + receiver.full_name + 'at' + str(chat.date)
        notification.save()
        return queryset




class ChatMessage(viewsets.ModelViewSet):
    model = ChatMessage
    serializer_class = ChatMessageSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    queryset = ChatMessage.objects.all()


class ArtistsendMessageList(generics.ListAPIView):
    model = ChatMessage
    serializer_class = SendMessageSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.sendermessages.all()
        return queryset

class ArtistReciveMessageList(generics.ListAPIView):
    model = ChatMessage
    serializer_class = SendMessageSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        for message in artist.receivemessages.all():
            message.is_read = True
            message.save()
        queryset = artist.receivemessages.all()
        return queryset

class ConversationMessageList(generics.ListAPIView):
    model = ChatMessage
    serializer_class = ConversationMessageSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        data = self.request.GET
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
            reciver = Artist.objects.get(id= data['reciver_id'])
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = self.model.queryset.filter(Q(sender=artist)|Q(sender=reciver)&Q(receiver=artist)|Q(receiver=reciver))
        print type(queryset)
        return queryset

class ProjectTypeViewSet(viewsets.ModelViewSet):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    queryset = ProjectType.objects.all().order_by('-id')
    serializer_class = ProjectTypeSerializer



class ProjectAPI(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    parser_classes = (MultiPartParser, FormParser,)

    def get_object(self, pk):
        try:
            return Project.objects.get(pk=pk)
        except Project.DoesNotExist:
            raise Http404

    def get(self, request, pk, format=None):
        artist = self.get_object(pk)
        serializer = ProjectSerializer(artist)
        return JSONResponse(serializer.data)

    def post(self, request, pk=None, format=None):
        data = request.data
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        required_fields = ['project_type','project_name','project_desc','from_date','to_date',
        'is_fetaured','is_active']
        data = request.data
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field):
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = Artist.objects.get(artist_token=token.user)
        except:
            return JSONResponse({'status':"error", "message":"User not found Permission Denied"})
        if pk:
            project = get_object_or_404(Project, pk=pk)
            if not project.project_owner == user:
                return JSONResponse({'status':"error", "message":"You don't have permission to edit the project"})
            project.project_name = data.get('project_name')
            project.project_desc = data.get('project_desc')
            project.from_date = datetime.datetime.strptime(data.get('from_date'), "%d-%m-%Y")
            project.to_date = datetime.datetime.strptime(data.get('to_date'), "%d-%m-%Y")
            project.image_content_desc = data.get('image_content_desc','')
            project.audio_url = data.get('audio_url','')
            project.audio_content_desc = data.get('audio_content_desc','')
            project.video_url = data.get('video_url','')
            project.video_content_desc = data.get('video_content_desc','')
            if data.get('project_image'):
                filename = data.get('project_image').name
                content = data.get('project_image').read()
                conn = S3Connection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
                bucket = conn.create_bucket("craftermediafiles")
                mime = mimetypes.guess_type(filename)[0]
                k = Key(bucket)
                k.key = filename
                k.set_metadata("Content-Type", mime)
                k.set_contents_from_string(content)
                k.set_acl("public-read")
                url = "http://craftermediafiles.s3.amazonaws.com/"+str(filename)
                project.project_image = url
            if data.get('is_fetaured') == 1:
                project.is_fetaured = True 
            else: 
                project.is_fetaured = False
            if data.get('is_active') == 1:
                project.is_active = True
            else:
                project.is_active = False
            project.save()
            if data.get('project_type'):
                for item in data.get('project_type'):
                    try:
                        projtype = ProjectType.objects.get(id=item)
                        project.project_type.add(item)
                        project.save()
                    except:
                        pass


        else:
            project = Project.objects.create(project_owner = user,project_name = data.get('project_name'),
                        project_desc = data.get('project_desc'),from_date = datetime.datetime.strptime(data.get('from_date'), "%d-%m-%Y"),
                        to_date = datetime.datetime.strptime(data.get('to_date'), "%d-%m-%Y"),
                        image_content_desc = data.get('image_content_desc',''),audio_url = data.get('audio_url',''),
                        audio_content_desc = data.get('audio_content_desc',''),video_url = data.get('video_url',''),
                        video_content_desc = data.get('video_content_desc',''))
            if data.get('project_image'):
                filename = data.get('project_image').name
                content = data.get('project_image').read()
                conn = S3Connection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
                bucket = conn.create_bucket("craftermediafiles")
                mime = mimetypes.guess_type(filename)[0]
                k = Key(bucket)
                k.key = filename
                k.set_metadata("Content-Type", mime)
                k.set_contents_from_string(content)
                k.set_acl("public-read")
                url = "http://craftermediafiles.s3.amazonaws.com/"+str(filename)
                project.project_image = url

            if data.get('is_fetaured') == 1:
                project.is_fetaured = True 
            else: 
                project.is_fetaured = False
            if data.get('is_active') == 1:
                project.is_active = True
            else:
                project.is_active = False
            project.save()
            if data.get('project_type'):
                for item in data.get('project_type'):
                    try:
                        projtype = ProjectType.objects.get(id=item)
                        project.project_type.add(item)
                        project.save()
                    except:
                        pass
        detail_url = ''
        return JSONResponse({'status':"success", "message":"Successfully Updated Project",'project_name':project.project_name, 'detial':detail_url})



class AddProjectMember(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    # def get_object(self, pk):
    #     try:
    #         return Project.objects.get(pk=pk)
    #     except Project.DoesNotExist:
    #         raise Http404

    # def get(self, request, pk, format=None):
    #     artist = self.get_object(pk)
    #     serializer = ProjectSerializer(artist)
    #     return JSONResponse(serializer.data)

    def post(self, request, format=None):
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        required_fields = ['project_id','member_id']
        data = request.data
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field) and not type(data.get(field)) == str:
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = Artist.objects.get(artist_token=token.user)
        except:
            return JSONResponse({'status':"error", "message":"User not found Permission Denied"})

        try:
            member = Artist.objects.get(id=int(data.get('member_id')))
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":"Member Doe's not exist"})

        if user and member:
            pk = data.get('project_id')
            try:
                project = get_object_or_404(Project, pk=pk)
            except:
                return JSONResponse({'status':"error", "message":"Project Doesnot Exist"})
            if project.project_owner != user:
                return JSONResponse({'status':"error", "message":"Not autherized project owner"})
            if member.id == user.id:
                return JSONResponse({'status':"error", "message":"You can't add Member as you"})
            if UserRequest.objects.filter(to_user=member, request_type='PR', project=project):
                return JSONResponse({'status':"error", "message":"Already requested"})
            user_req = UserRequest.objects.create(from_user=user, to_user=member,request_type='PR',
            project=project)
            return JSONResponse({'status':"success", "message":"Requested Successfully"})
        else:
            return JSONResponse({'status':"error", "message":"SOmething went wrong please try again"})



# class ProjectAcceptView(APIView):
#     authentication_classes = (TokenAuthentication,)
#     permission_classes = (IsAuthenticated)

#     




class ProjectAcceptView(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def post(self, request, format=None):
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        required_fields = ['request_id','is_accept']
        data = request.data
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field) and int(data.get(field)):
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = Artist.objects.get(artist_token=token.user)
        except:
            return JSONResponse({'status':"error", "message":"User not found"})
        if UserRequest.objects.filter(to_user=user,is_accept=True,id=int(data.get('request_id'))):
            return JSONResponse({'status':"error", "message":"Request Already Accepted"})
        else:
            try:
                user_req = UserRequest.objects.get(to_user=user,id=data.get('request_id'))
                if user_req:
                    project = Project.objects.get(id=user_req.project.id)
                    if ProjectMembers.objects.filter(project__id=project.id, member=user):
                        return JSONResponse({'status':"error", "message":"Already Member"})
                    else:
                        try:
                            project_mem = ProjectMembers.objects.get(project__id=project.id)
                        except ObjectDoesNotExist:
                            return JSONResponse({'status':"error", "message":"Project Does'nt exist"})
                        if project_mem:
                            project_mem.project_member = user
                            project.updated_date =  datetime.datetime.now()
                            project.is_active = True
                            project.is_added = True
                            project.save()
                            if user_req.is_accept == False:
                                user_req.is_accept = True
                                user_req.update_date = datetime.datetime.now()
                                user_req.save()
                                return JSONResponse({'status':"success", "message":"Accepted Successfully"})
                            else:
                                pass
                        else:
                            pass

            except:
                return JSONResponse({'status':"error", "message":"Something went wrong"})


class UserRequestAPIView(generics.ListAPIView):
    model = UserRequest
    serializer_class = UserRequestSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.requests.all()
        return querysets

class ImageContentAPI(viewsets.ModelViewSet):
    model = ImageContent
    serializer_class = ImageContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    queryset = ImageContent.objects.all()

class UserImagecontentAPIView(generics.ListAPIView):
    model = ImageContent
    serializer_class = ImageContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_object(self, pk):
        try:
            return ImageContent.objects.get(pk=pk)
        except ImageContent.DoesNotExist:
            raise Http404

    def get(self, request, pk, format=None):
        image = self.get_object(pk)
        serializer = ImageContentSerializer(image)
        return JSONResponse(serializer.data)

class GetUserImagescontentAPIView(generics.ListAPIView):
    model = ImageContent
    serializer_class = ImageContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.imagecontents.all()
        return queryset



class UserImageContent(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    parser_classes = (MultiPartParser, FormParser,)


    
    def post(self, request, pk=None, format=None):
        data = request.data
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        required_fields = ['image', 'image_content','is_active']
        data = request.data
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field):
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = Artist.objects.get(artist_token=token.user)
        except:
            return JSONResponse({'status':"error", "message":"User not found Permission Denied"})
        if data.get('image'):
            filename = data.get('image').name
            content = data.get('image').read()
            conn = S3Connection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
            bucket = conn.create_bucket("craftermediafiles")
            mime = mimetypes.guess_type(filename)[0]
            k = Key(bucket)
            k.key = filename
            k.set_metadata("Content-Type", mime)
            k.set_contents_from_string(content)
            k.set_acl("public-read")
            image_file = "http://craftermediafiles.s3.amazonaws.com/"+str(filename)

        if pk:
            try:
                img_cont = ImageContent.objects.get(id=pk, artist=user)
            except ImageContent.DoesNotExist:
                return JSONResponse({'status':"error", "message":"Image Content Does't Exist"})
            else:
                img_cont.video_desc = data.get('image_content')
                img_cont.image_file = image_file
                img_cont.save()
        else:
            img_cont = ImageContent.objects.create(
                artist=user,image_file=image_file,video_desc=data.get('image_content'))
        if data.get('is_active') == 1:
            img_cont.active = True
        else:
            img_cont.active = False
        img_cont.save()

        category = 'UPI'
        subject = '{0} uploaded a new image'.format(user.full_name)
        sender = settings.SITE_URL+'/api/v1/artist/{0}/'.format(user.id)
        desc = '{0} uploaded new image'.format(sender)
        url = settings.SITE_URL+'/api/v1/get-all-image-contents/'+str(img_cont.id)+'/'
        notification  = Notifications.objects.create(subject=subject,sender=user,category=category, description=desc,url=url)
        return JSONResponse({'status':"success", "message":"Successfully Uploaded Image"})


class VideoentAPI(viewsets.ModelViewSet):
    model = VideoContent
    serializer_class = VideoContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    queryset = VideoContent.objects.all()

class UserVideocontentAPIView(generics.ListAPIView):
    model = VideoContent
    serializer_class = VideoContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_object(self, pk):
        try:
            return VideoContent.objects.get(pk=pk)
        except VideoContent.DoesNotExist:
            raise Http404

    def get(self, request, pk, format=None):
        video = self.get_object(pk)
        serializer = VideoContentSerializer(video)
        return JSONResponse(serializer.data)


class GetUserVideocontentAPIView(generics.ListAPIView):
    model = VideoContent
    serializer_class = VideoContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.videocontents.all()
        return queryset



class UserVideoContent(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    def post(self, request, pk=None, format=None):
        data = request.data
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        required_fields = ['video_url', 'video_content','is_active']
        data = request.data
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field):
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = Artist.objects.get(artist_token=token.user)
        except:
            return JSONResponse({'status':"error", "message":"User not found Permission Denied"})
        if pk:
            try:
                video_cont = VideoContent.objects.get(id=pk, artist=user)
            except ImageContent.DoesNotExist:
                return JSONResponse({'status':"error", "message":"Image Content Does't Exist"})
            else:
                video_cont.video_url = data.get('video_url')
                video_cont.video_desc = data.get('video_content')
                video_cont.save()
        else:
            video_cont = VideoContent.objects.create(
                artist=user,video_url=data.get('video_url'),video_desc=data.get('video_content'))
        if data.get('is_active') == 1:
            video_cont.active = True
        else:
            video_cont.active = False
        video_cont.save()

        category = 'UPV'
        subject = '{0} uploaded a new video'.format(user.full_name)
        sender = settings.SITE_URL+'/api/v1/artist/{0}/'.format(user.id)
        desc = '{0} uploaded new video'.format(sender)
        url = settings.SITE_URL+'/api/v1/get-all-video-contents/'+str(video_cont.id)+'/'
        notification  = Notifications.objects.create(subject=subject,sender=user,category=category, description=desc,url=url)
        return JSONResponse({'status':"success", "message":"Successfully Uploaded Video"})



#### Audio

class AudioContentAPI(viewsets.ModelViewSet):
    model = AudioContent
    serializer_class = AudioContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    queryset = AudioContent.objects.all()

class UserAudiocontentAPIView(generics.ListAPIView):
    model = AudioContent
    serializer_class = AudioContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_object(self, pk):
        try:
            return AudioContent.objects.get(pk=pk)
        except AudioContent.DoesNotExist:
            raise Http404

    def get(self, request, pk, format=None):
        video = self.get_object(pk)
        serializer = AudioContentSerializer(video)
        return JSONResponse(serializer.data)


class GetUserAudiocontentAPIView(generics.ListAPIView):
    model = AudioContent
    serializer_class = AudioContentSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        header = self.request.META.get('HTTP_AUTHORIZATION').split()[1]
        token = Token.objects.get(key=header)
        try:
            artist = Artist.objects.get(artist_token=token.user)
        except Artist.DoesNotExist:
            return JSONResponse({'status':"error", "message":""})
        queryset = artist.audiocontents.all()
        return queryset



class UserAudioContent(APIView):
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    def post(self, request, pk=None, format=None):
        data = request.data
        header = request.META.get('HTTP_AUTHORIZATION').split()[1]
        required_fields = ['audio_url', 'audio_content','is_active']
        data = request.data
        for field in required_fields:
            if field not in data.keys():
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field required" .format(field) })
            elif not data.get(field):
                return JSONResponse({'status':"error", "field_name":field, "message":"{0} field not empty" .format(field) })
        try:
            token = Token.objects.get(key=str(header))
            user = Artist.objects.get(artist_token=token.user)
        except:
            return JSONResponse({'status':"error", "message":"User not found Permission Denied"})
        if pk:
            try:
                audio_cont = AudioContent.objects.get(id=pk, artist=user)
            except AudioContent.DoesNotExist:
                return JSONResponse({'status':"error", "message":"Image Content Does't Exist"})
            else:
                audio_cont.audio_url = data.get('audio_url')
                audio_cont.audio_desc = data.get('audio_content')
                audio_cont.save()
        else:
            audio_cont = AudioContent.objects.create(
                artist=user,audio_url=data.get('audio_url'),audio_desc=data.get('audio_content'))
        if data.get('is_active') == 1:
            audio_cont.active = True
        else:
            audio_cont.active = False
        audio_cont.save()

        category = 'UPA'
        subject = '{0} uploaded a new Audio'.format(user.full_name)
        sender = settings.SITE_URL+'/api/v1/artist/{0}/'.format(user.id)
        desc = '{0} uploaded new audio'.format(sender)
        url = settings.SITE_URL+'/api/v1/get-all-image-contents/'+str(audio_cont.id)+'/'
        notification  = Notifications.objects.create(subject=subject,sender=user,category=category, description=desc,url=url)
        return JSONResponse({'status':"success", "message":"Successfully Uploaded Audio"})


class NotificationsAPIView(viewsets.ModelViewSet):
    model = Notifications
    serializer_class = NotificationSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)
    queryset = Notifications.objects.all().exclude(category='MGS')