gistfile1.txt

import json
import requests
import binascii
import os
from rest_framework import mixins, viewsets, permissions, views, status

from accounts import models as accounts_models
from accounts import permissions as accounts_permissions
from accounts import serializers as accounts_serializers

from configurations import models as configurations_models

from rest_framework.response import Response
from rest_framework.exceptions import NotAuthenticated

from rest_framework.authtoken.views import ObtainAuthToken

from rest_framework.exceptions import ParseError
from rest_framework.parsers import FileUploadParser, MultiPartParser

from rest_framework.authtoken.models import Token

from requests_oauthlib import OAuth1
from urllib.parse import parse_qs, parse_qsl

from django.conf import settings

obtain_auth_token = ObtainAuthToken.as_view(
    serializer_class=accounts_serializers.AuthTokenSerializer
)

#Cargar Imagenes
class FileUploadView(views.APIView):
    parser_classes = (MultiPartParser,)

    def post(self, request, format=None):
        file_obj = request.data['file']
        image = accounts_models.Image.objects.create(image=file_obj)
        return Response({'url':image.image.url},status=200)

class SignupVerify(views.APIView):
    permission_classes = (permissions.AllowAny,)

    def get(self, request, format=None):
        code = request.GET.get('code', '')
        
        if code != '':
            try:
                user = accounts_models.User.objects.get(code=code)
                user.is_verified = True
                user.code = ''
                try:
                    user_referral = accounts_models.User.objects.get(referral_code=user.referral_code_temp)
                    user_referral.referral_user += configurations_models.Howwin.objects.get(id=1).crowns
                    user_referral.save()
                    user.referral_code_temp = ''
                except:
                    pass
                user.save()
                content = {'success': True}
                return Response(content, status=status.HTTP_200_OK)
            except:
                content = {'success': False}
                return Response(content, status=status.HTTP_400_BAD_REQUEST)
        else:
            content = {'success': False}
            return Response(content, status=status.HTTP_400_BAD_REQUEST)

class UserViewSet(viewsets.ModelViewSet):
    queryset = accounts_models.User.objects.all()
    serializer_class = accounts_serializers.UserSerializer
    permission_classes = (accounts_permissions.IsOwnerOrReadOnly,)

    def list(self, request, *args, **kwargs):
        if request.user.is_authenticated():
            if not request.user.is_staff:
                queryset = self.filter_queryset(self.get_queryset()).filter(id=request.user.id)
                serializer = self.get_serializer(queryset, many=True)
                return Response(serializer.data[0])
            else:
                queryset = self.filter_queryset(self.get_queryset())
                serializer = self.get_serializer(queryset, many=True)
                me = {}
                users = []
                for data in serializer.data:
                    if data["id"] == request.user.id:
                        me = data
                    else:
                        users.append(data)
                return Response({"admin": True,'me': me, "users": users})
        else:
            raise NotAuthenticated

class MultipleAccountsView(views.APIView):
    parser_classes = (MultiPartParser,)
    permission_classes = (permissions.IsAuthenticated, permissions.IsAdminUser,)

    def post(self, request, format=None):
        file_obj = request.data.get('file')
        if file_obj:
            try:
                users = json.loads(file_obj.read().decode('utf-8'))
                if (isinstance(users, list)):
                    data_list = []
                    for user in users:
                        if (isinstance(user, dict)):
                            serializer = accounts_serializers.UserSerializerMultiple(data=user, partial=True)
                            if (serializer.is_valid()):
                                accounts_models.User(**serializer.validated_data).save()
                                #data = {
                                #    "id_guerrero": user["id_guerrero"],
                                #    "user_response": {"success": True}
                                #}
                            else:
                                data = {
                                    "id_guerrero": user["id_guerrero"],
                                    "errors": serializer.errors
                                }
                                data_list.append(data)
                        else:
                            print("users not is dict")
                    if len(data_list) == 0:
                        data_list = {"success": True}
                    return Response(data_list,status=200)
                else:
                    raise ParseError("users not is list")
            except ValueError as err:
                raise ParseError("users not is correct")
        else:
            raise ParseError("users not exists")

class SignupIdGuerrero(views.APIView):
    permission_classes = (permissions.AllowAny,)

    def post(self, request, format=None):
        id_guerrero = str(request.data.get('id_guerrero'))
        if id_guerrero:        
            try:
                user = accounts_models.User.objects.get(id_guerrero=id_guerrero)
                user.save()
                serializer = accounts_serializers.UserSerializerMultiple(user)
                token = str(Token.objects.get_or_create(user=user)[0])
                content = {'user': serializer.data, 'token': token}
                return Response(content, status=status.HTTP_200_OK)
            except:
                raise ParseError("id_guerrero not in database")
        else:
            raise ParseError("id_guerrero not exists")


class SignupFacebook(views.APIView):
    def post(self, request, format=None):
        access_token_url = 'https://graph.facebook.com/v2.3/oauth/access_token'
        graph_api_url = 'https://graph.facebook.com/v2.3/me'
        params = {
            'client_id': request.data.get('clientId'),
            'redirect_uri': request.data.get('redirectUri'),
            'client_secret': settings.FACEBOOK_SECRET,
            'code': request.data.get('code')
        }

        r = requests.get(access_token_url, params=params)
        access_token = json.loads(r.text)
        r = requests.get(graph_api_url, params=access_token)
        profile = json.loads(r.text)

        return Response(profile, status=status.HTTP_200_OK)

class SignupTwitter(views.APIView):
    def post(self, request, format=None):
        request_token_url = 'https://api.twitter.com/oauth/request_token'
        access_token_url = 'https://api.twitter.com/oauth/access_token'
        if request.data.get('oauth_token') and request.data.get('oauth_verifier'):
            auth = OAuth1(settings.TWITTER_ID,
                          client_secret=settings.TWITTER_SECRET,
                          resource_owner_key=request.data.get('oauth_token'),
                          verifier=request.data.get('oauth_verifier'))
            r = requests.post(access_token_url, auth=auth)
            profile = dict(parse_qsl(r.text))
            
            auth = OAuth1(settings.TWITTER_ID,
                client_secret=settings.TWITTER_SECRET,
                resource_owner_key=profile["oauth_token"],
                resource_owner_secret=profile["oauth_token_secret"])
            r = requests.get(
                'https://api.twitter.com/1.1/account/verify_credentials.json', 
                auth=auth, 
                params={
                    "include_email": 'true'
                }
            )
            profile = json.loads(r.text)
            return Response(profile, status=status.HTTP_200_OK)
        else:
            oauth = OAuth1(settings.TWITTER_ID,
                           client_secret=settings.TWITTER_SECRET,
                           callback_uri=request.data.get('redirectUri'))
            r = requests.post(request_token_url, auth=oauth)
            oauth_token = dict(parse_qsl(r.text))
            return Response(oauth_token, status=status.HTTP_200_OK)

class SignupGoogle(views.APIView):
    def post(self, request, format=None):
        access_token_url = 'https://accounts.google.com/o/oauth2/token'
        people_api_url = 'https://www.googleapis.com/plus/v1/people/me'
        payload = dict(client_id=request.data.get('clientId'),
                   redirect_uri=request.data.get('redirectUri'),
                   client_secret=settings.GOOGLE_SECRET,
                   code=request.data.get('code'),
                   grant_type='authorization_code')

        r = requests.post(access_token_url, data=payload)
        token = json.loads(r.text)
        print (token)
        headers = {'Authorization': 'Bearer {0}'.format(token['access_token'])}

        r = requests.get(people_api_url, headers=headers)
        profile = json.loads(r.text)

        return Response(profile, status=status.HTTP_200_OK)

class SignupInstagram(views.APIView):
    def post(self, request, format=None):
        access_token_url = 'https://api.instagram.com/oauth/access_token'
        graph_api_url = 'https://api.instagram.com/v1/users/self/'
        params = {
            'client_id': request.data.get('clientId'),
            'redirect_uri': request.data.get('redirectUri'),
            'client_secret': settings.INSTAGRAM_SECRET,
            'code': request.data.get('code'),
            'grant_type': 'authorization_code'
        }

        r = requests.post(access_token_url, params)
        print (r.text)
        access_token = json.loads(r.text)
        r = requests.get(graph_api_url, params={'access_token':access_token["access_token"]})
        profile = json.loads(r.text)
        return Response(profile, status=status.HTTP_200_OK)

from django.core.mail.message import EmailMultiAlternatives
from django.template.loader import render_to_string
class recoveryPassword(views.APIView):
    def post(self, request, format=None):
        username_or_email = request.data.get('username_or_email',None)
        if username_or_email:
            user = False
            try:
                user = accounts_models.User.objects.get(username=username_or_email)
            except:
                pass
            try:
                user = accounts_models.User.objects.get(email=username_or_email)
            except:
                pass

            if user:

                user.recovery = binascii.hexlify(os.urandom(20))
                user.save()

                try:
                    subject, from_email, to = 'Recuperar contrasena.', "(Club Corona) <%s>" % settings.EMAIL_HOST_USER, user.email
                    text_content = render_to_string("email/recovery_password.html",{"code": user.recovery})
                    html_content = render_to_string("email/recovery_password.html",{"code": user.recovery})
                    msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
                    msg.attach_alternative(html_content, "text/html")
                    msg.send()

                    return Response({"email":"send"},status=200)
                except:
                    raise ParseError("emails not send, intent of new")
            else:
                raise ParseError("username or email no exists")
        else:
            raise ParseError("username or email no exists")

from django.contrib.auth.hashers import make_password
class changePassword(views.APIView):
    def post(self, request, format=None):
        code = request.data.get('code',None)
        password = request.data.get('password',None)
        if code and password: 
            try:
                user = accounts_models.User.objects.get(recovery=code)
                user.password = make_password(password)
                user.recovery = '';
                user.save()
            except:
                raise ParseError("code is incorrect")
      
            return Response({"password": "change"},status=200)
        else:
            raise ParseError("code or password no exists")


class changePurchaseCode(views.APIView):
    def post(self, request, format=None):
        code = request.data.get('code',None)
        if code: 
            try:
                establishment = configurations_models.Establishment.objects.get(code=code)
                establishment.users_consumer.add(request.user)
                establishment.save()
            except:
                raise ParseError("code is incorrect")
      
            return Response({"purchasecode": "change"},status=200)
        else:
            raise ParseError("code no exists")


class SuperFanAPIView(views.APIView):
    def get(self, request, *args, **kwargs):
        users = sorted(accounts_models.User.objects.order_by("date_created"), key=lambda user: user.historical_crowns(), reverse=True)[:7]
        serializer = accounts_serializers.UserSerializer(users,many=True)
        return Response(serializer.data)