예제 #1
0
 def post(self, request, _id):
     user = request.yoo["user"]
     
     ticket = LotteryTicket.objects.get(pk=_id)
     
     if ticket.user != user:
         raise exceptions.WebServiceAuthorizationFailed()
     
     try:
         data = json.loads(request.body)
     except:
         data = {}
     
     type = data.get("type", None)
     if type not in ["facebook", "twitter"]:
         raise exceptions.WebServiceException("Unsupported Share Type")
     
     if not ticket.coin_share_transaction.filter(type=type).exists():
         parent = CoinTransaction(wallet=user.get_wallet())
         parent.save()
         
         transaction = CoinShareTransaction(ticket=ticket, type=type, transaction=parent)
         transaction.save()
         
         parent.amount = transaction.amount
         parent.save()
         
     return self.get(request, _id)
예제 #2
0
    def update(self):
        if self._device:
            self._allocated = 0

            # Process Checked v.s. Unchecked
            if not CoinTicketTransaction.objects.filter(ticket=self._ticket).exists():
                transaction = CoinTransaction(wallet=self._wallet)
                transaction.save()

                try:
                    self.add_coins()
                except:
                    pass

                # Create Record linking Ticket to Transaction
                transaction_ticket = CoinTicketTransaction(ticket=self._ticket, transaction=transaction)
                transaction_ticket.save()
            else:
                transaction_ticket = CoinTicketTransaction.objects.get(ticket=self._ticket)
                transaction = transaction_ticket.transaction

            # Allocate Coins
            # Changed: This will never de-allocate a coin, if you submit and check
            # ONCE you get the coin, if you add more submissions and do not check
            # this coin is not lost.
            coins = COINS_PER_PLAY if self._ticket.unchecked == 0 else 0
            if transaction.amount < coins:
                self.add_coins()
                transaction.amount = coins
                transaction_ticket.checked = True
                transaction.save()
                transaction_ticket.save()
                self._allocated += coins

            del transaction

            # Process for Submissions
            # For every submission we grant COINS_PER_PLAY __regardless__ of how
            # many plays there are for that submission. In addition there is a limit
            # of COINS_PER_DAY_MAX via this mechanism (others are not effected)

            submissions = self._ticket.submissions.all()

            for submission in submissions:
                if not CoinSubmissionTransaction.objects.filter(submission=submission).exists():
                    transaction = CoinTransaction(wallet=self._wallet)
                    transaction.save()

                    # Create Record linking Ticket to Transaction
                    transaction_submission = CoinSubmissionTransaction(submission=submission, transaction=transaction)
                    transaction_submission.save()
                else:
                    transaction_submission = CoinSubmissionTransaction.objects.get(submission=submission)
                    transaction = transaction_submission.transaction

                coins = COINS_PER_PLAY
                delta = coins - transaction.amount

                if not delta > 0:
                    continue

                # Maximum number of submission coins that remain to be granted for
                # the day
                remaining = COINS_PER_DAY_MAX - CoinTicketManager.for_user_on_day(
                    self._wallet.user, submission.added_at
                )

                if not remaining:
                    continue

                    transaction.amount = coins
                    transaction.save()

                    self._allocated += coins
                else:
                    self._allocated = 0

                # Process Checked v.s. Unchecked
                if not CoinTicketTransaction.objects.filter(ticket=self._ticket).exists():
                    transaction = CoinTransaction(wallet=self._wallet)
                    transaction.save()

                    # Create Record linking Ticket to Transaction
                    transaction_ticket = CoinTicketTransaction(ticket=self._ticket, transaction=transaction)
                    transaction_ticket.save()
                else:
                    transaction_ticket = CoinTicketTransaction.objects.get(ticket=self._ticket)
                    transaction = transaction_ticket.transaction

                # Allocate Coins
                # Changed: This will never de-allocate a coin, if you submit and check
                # ONCE you get the coin, if you add more submissions and do not check
                # this coin is not lost.
                coins = COINS_PER_PLAY if self._ticket.unchecked == 0 else 0
                if transaction.amount < coins:
                    transaction.amount = coins
                    transaction_ticket.checked = True
                    transaction.save()
                    transaction_ticket.save()
                    self._allocated += coins

                del transaction

                # Process for Submissions
                # For every submission we grant COINS_PER_PLAY __regardless__ of how
                # many plays there are for that submission. In addition there is a limit
                # of COINS_PER_DAY_MAX via this mechanism (others are not effected)

                submissions = self._ticket.submissions.all()

                for submission in submissions:
                    if not CoinSubmissionTransaction.objects.filter(submission=submission).exists():
                        transaction = CoinTransaction(wallet=self._wallet)
                        transaction.save()

                        # Create Record linking Ticket to Transaction
                        transaction_submission = CoinSubmissionTransaction(
                            submission=submission, transaction=transaction
                        )
                        transaction_submission.save()
                    else:
                        transaction_submission = CoinSubmissionTransaction.objects.get(submission=submission)
                        transaction = transaction_submission.transaction

                    coins = COINS_PER_PLAY
                    delta = coins - transaction.amount

                    if not delta > 0:
                        continue

                    # Maximum number of submission coins that remain to be granted for
                    # the day
                    remaining = COINS_PER_DAY_MAX - CoinTicketManager.for_user_on_day(
                        self._wallet.user, submission.added_at
                    )

                    if not remaining:
                        continue

                    transaction.amount = coins
                    transaction.save()

                    self._allocated += coins
예제 #3
0
    def post(self, request):
        """
        Updates the details of the currently logged in user
        """
        
        if request.yoo["new_version"]:
             if not request.yoo["user"] and request.yoo["auth"].get("__internal__reject__", False):
                raise exceptions.WebServiceAuthorizationFailed()
             user = request.yoo["user"]
             device = request.yoo["device"]
            
             try:
                data = json.loads(request.body)
             except:
                data = request.POST
                
             form = UserUpdateForm(data)
             if not form.is_valid():
                raise exceptions.WebServiceFormValidationFailed(form)

             email = form.cleaned_data["email"]
             password = form.cleaned_data["password"]
                
             # Routing Logic        
             '''if email and password:
                self._modify_email(user, email, password)
             elif email:
                self._modify_email(user, email, password=None)
             elif password:
                self._modify_password(user, password)'''
            
             existing = dict([[x.name, x] for x in user.tokens.all()])
            
             for key in ["fbToken", "twitterToken", "contestEmail", "requestedEmail"]:
                if key not in data:
                    continue
                
                if not form.cleaned_data[key]:
                    if key in existing:
                        existing[key].delete()
                else:
                    if key in existing:
                        existing[key].token = form.cleaned_data[key]
                    else:
                        existing[key] = UserToken(user=user, name=key, token=form.cleaned_data[key])
                
                    existing[key].save()
                    
             if "pushToken" in form.cleaned_data and form.cleaned_data["pushToken"]:
                request.yoo["device"].device_token = form.cleaned_data["pushToken"]
                request.yoo["device"].save()
                
             if "referral" in form.cleaned_data and form.cleaned_data["referral"]:
                user.referral = form.cleaned_data["referral"]
                user.save()

             if email:
                try:
                    coins_record, created = EmailCoins.objects.get_or_create(email=email,defaults={'coins': 0})
                except:
                    coins_record = EmailCoins.objects.filter(email=email)[0]
                coins_record.save()

            
             if user.password and user.email or user.tokens.filter(name="requestedEmail").exists():
                try:
                    CoinTicketGenericTransaction.objects.get(user=user, type="register")
                except CoinTicketGenericTransaction.DoesNotExist:
                    transaction = CoinTransaction(wallet=user.get_wallet())
                    transaction.save()
                    
                    _coins = CoinTicketGenericTransaction(user=user, type="register", transaction=transaction)
                    _coins.save()
                                    
                    transaction.amount = _coins.amount
                    transaction.save()
                try:
                    device_record = DeviceCoins.objects.filter(device_id=request.yoo['device'])[0]
                except:
                    device_record,created = DeviceCoins.objects.get_or_create(device_id=request.yoo['device'])
                device_record.coins = F('coins') + int(_coins.amount)
                device_record.save()

             try:
                ClientLoginRecord, created = UserClientLogin.objects.get_or_create(device=request.yoo['device'], defaults={})
             except:
                ClientLoginRecord  = UserClientLogin.objects.filter(device=request.yoo['device'])[0]
             if data.has_key('fbToken')  or data.has_key('twitterToken'):
                ClientLoginRecord.client_login = data['user_email']
             else:
                ClientLoginRecord.client_login = email
             ClientLoginRecord.save()
             return self.get(request)
        else:
      
         # Short-Circuit for Authentication Errors caused by invalid Device IDs
             if not request.yoo["user"] and request.yoo["auth"].get("__internal__reject__", False):
                raise exceptions.WebServiceAuthorizationFailed()
            
             user = request.yoo["user"]
             device = request.yoo["device"]
            
             try:
                data = json.loads(request.body)
             except:
                data = request.POST
            
             form = UserUpdateForm(data)
             if not form.is_valid():
                raise exceptions.WebServiceFormValidationFailed(form)

             email = form.cleaned_data["email"]
             password = form.cleaned_data["password"]
                    
             # Routing Logic        
             if email and password:
                self._modify_email(user, email, password)
             elif email:
                self._modify_email(user, email, password=None)
             elif password:
                self._modify_password(user, password)
            
             existing = dict([[x.name, x] for x in user.tokens.all()])
            
             for key in ["fbToken", "twitterToken", "contestEmail", "requestedEmail"]:
                if key not in data:
                    continue
                
                if not form.cleaned_data[key]:
                    if key in existing:
                        existing[key].delete()
                else:
                    if key in existing:
                        existing[key].token = form.cleaned_data[key]
                    else:
                        existing[key] = UserToken(user=user, name=key, token=form.cleaned_data[key])
                
                    existing[key].save()
                    
             if "pushToken" in form.cleaned_data and form.cleaned_data["pushToken"]:
                request.yoo["device"].device_token = form.cleaned_data["pushToken"]
                request.yoo["device"].save()
                
             if "referral" in form.cleaned_data and form.cleaned_data["referral"]:
                user.referral = form.cleaned_data["referral"]
                user.save()
            
             if user.tokens.filter(name="requestedEmail").exists():
                try:
                    CoinTicketGenericTransaction.objects.get(user=user, type="register")
                except CoinTicketGenericTransaction.DoesNotExist:
                    transaction = CoinTransaction(wallet=user.get_wallet())
                    transaction.save()
                    
                    _coins = CoinTicketGenericTransaction(user=user, type="register", transaction=transaction)
                    _coins.save()
                                    
                    transaction.amount = _coins.amount
                    transaction.save()
            
             return self.get(request)
        
        def _modify_password(self, user, password):
            user.password = hashers.make_password(password)
            user.save()                
        
        def _modify_email(self, user, email, password):
            # Search Others
            other = YooLottoUser.objects.filter(email=email)
            
            # Exclude current user
            if user:
                other = other.exclude(pk=user.pk)
            
            if not other:
                user.email = email
                
                if password:
                    user.password = hashers.make_password(password)
                
                user.save()
                
                return
            
            other = other[0]
            if not other.password:
                self._merge(user, email, other)
                return
                                    
            if not password:
                raise exceptions.WebServiceAuthorizationFailed("AUTH_REQUIRED")
            
            if hashers.check_password(password, other.password):
                self._merge(user, email, other)            
                return
            
            raise exceptions.WebServiceAuthorizationFailed("AUTH_INVALID")
            
        def _merge(self, user, email, other):
            from yoolotto.legacy.migration.tickets import MigrateTickets
            from yoolotto.legacy.models import Tickets as LegacyTicket, Users as LegacyUser
            
            # Import Data
            try:
                for legacy in LegacyUser.objects.filter(email=email):
                        MigrateTickets(legacy, user).run()
            except:
                pass
            # Users
            devices = user.devices.all()
            
            # Magic Here...
            for device in devices:
                device.user = other
                device.save()
                
            other.save()        
예제 #4
0
    def post(self, request):
        """
        Updates the details of the currently logged in user
        """
        # Short-Circuit for Authentication Errors caused by invalid Device IDs

        if request.yoo["new_version"]:
            if not request.yoo["user"] and request.yoo["auth"].get("__internal__reject__", False):
                raise exceptions.WebServiceAuthorizationFailed()
            user = request.yoo["user"]
            device = request.yoo["device"]

            try:
                data = json.loads(request.body)
            except:
                data = request.POST
            print data
            form = UserUpdateForm(data)
            if not form.is_valid():
                raise exceptions.WebServiceFormValidationFailed(form)
            email = form.cleaned_data["email"]
            password = form.cleaned_data["password"]
            # Routing Logic
            if email and password:
                self._modify_email(user, email, password)
            elif email:
                self._modify_email(user, email, password=None)
            elif password:
                self._modify_password(user, password)

            existing = dict([[x.name, x] for x in user.tokens.all()])
            for key in ["fbToken", "twitterToken", "contestEmail", "requestedEmail"]:
                if key not in data:
                    continue

                if not form.cleaned_data[key]:
                    if key in existing:
                        existing[key].delete()
                else:
                    if key in existing:
                        existing[key].token = form.cleaned_data[key]
                    else:
                        existing[key] = UserToken(user=user, name=key, token=form.cleaned_data[key])

                    existing[key].save()

            if "pushToken" in form.cleaned_data and form.cleaned_data["pushToken"]:
                request.yoo["device"].device_token = form.cleaned_data["pushToken"]
                request.yoo["device"].save()

            if "referral" in form.cleaned_data and form.cleaned_data["referral"]:
                user.referral = form.cleaned_data["referral"]
                user.save()
            print "the email obtained is", type(email)
            try:
                ClientLoginRecord, created = UserClientLogin.objects.get_or_create(
                    device=request.yoo["device"], defaults={}
                )
            except:
                ClientLoginRecord = UserClientLogin.objects.filter(device=request.yoo["device"])[0]
            try:
                if data["fbToken"] != "":
                    ClientLoginRecord.client_login = data["user_email"]
                    email = data["user_email"]
                elif data["twitterToken"] != "":
                    ClientLoginRecord.client_login = data["user_email"]
                    email = data["user_email"]
                else:
                    ClientLoginRecord.client_login = email
            except:
                try:
                    if data["twitterToken"] != "":
                        ClientLoginRecord.client_login = data["user_email"]
                        email = data["user_email"]
                    else:
                        ClientLoginRecord.client_login = email
                except:
                    ClientLoginRecord.client_login = email
            ClientLoginRecord.email_source = data["email_source"]
            ClientLoginRecord.save()
            if email:
                try:
                    if data["email_source"] == "facebook":
                        coins_record, created = EmailCoins.objects.get_or_create(
                            email=email,
                            email_source=data["email_source"],
                            defaults={"coins": 0.5, "reset_date": datetime.datetime.now()},
                        )
                    else:
                        coins_record, created = EmailCoins.objects.get_or_create(
                            email=email,
                            email_source=data["email_source"],
                            defaults={"coins": 0, "reset_date": datetime.datetime.now()},
                        )
                except:
                    coins_record = EmailCoins.objects.filter(email=email, email_source=data["email_source"])[0]
                try:
                    device_record, created = DeviceCoins.objects.get_or_create(
                        device_id=request.yoo["device"], defaults={"coins": 1, "reset_date": datetime.datetime.now()}
                    )
                except:
                    device_record = DeviceCoins.objects.filter(device_id=request.yoo["device"])[0]
                if device_record.coins != 0:
                    coins_record.coins = coins_record.coins + device_record.coins
                    device_record.coins = 0
                    device_record.save()
                coins_record.save()
            if data["email_source"] == "facebook" or data["email_source"] == "twitter":
                try:
                    login_details, created = DeviceLoginDetails.objects.get_or_create(
                        device=request.yoo["device"], email=data["user_email"], user=request.yoo["user"]
                    )
                except:
                    login_details = DeviceLoginDetails.objects.filter(
                        device=request.yoo["device"], email=data["user_email"], user=request.yoo["user"]
                    )[0]
                print request.yoo["device"]
                print data["user_email"]
                print login_details
            # print reset_coins_record

            if user.password and user.email or user.tokens.filter(name="requestedEmail").exists():
                try:
                    CoinTicketGenericTransaction.objects.get(user=user, type="register")
                except CoinTicketGenericTransaction.DoesNotExist:
                    transaction = CoinTransaction(wallet=user.get_wallet())
                    transaction.save()

                    _coins = CoinTicketGenericTransaction(user=user, type="register", transaction=transaction)
                    _coins.save()

                    transaction.amount = _coins.amount
                    transaction.save()
                    try:
                        device_record = DeviceCoins.objects.get(device_id=request.yoo["device"])
                    except:
                        device_record = DeviceCoins.objects.filter(device_id=request.yoo["device"])[0]
                    device_record.coins = F("coins") + int(_coins.amount)
                    device_record.save()

            return self.get(request)
        else:

            # Short-Circuit for Authentication Errors caused by invalid Device IDs
            if not request.yoo["user"] and request.yoo["auth"].get("__internal__reject__", False):
                raise exceptions.WebServiceAuthorizationFailed()

            user = request.yoo["user"]
            device = request.yoo["device"]

            try:
                data = json.loads(request.body)
            except:
                data = request.POST

            form = UserUpdateForm(data)
            if not form.is_valid():
                raise exceptions.WebServiceFormValidationFailed(form)

            email = form.cleaned_data["email"]
            password = form.cleaned_data["password"]

            # Routing Logic
            if email and password:
                self._modify_email(user, email, password)
            elif email:
                self._modify_email(user, email, password=None)
            elif password:
                self._modify_password(user, password)

            existing = dict([[x.name, x] for x in user.tokens.all()])

            for key in ["fbToken", "twitterToken", "contestEmail", "requestedEmail"]:
                if key not in data:
                    continue

                if not form.cleaned_data[key]:
                    if key in existing:
                        existing[key].delete()
                else:
                    if key in existing:
                        existing[key].token = form.cleaned_data[key]
                    else:
                        existing[key] = UserToken(user=user, name=key, token=form.cleaned_data[key])

                    existing[key].save()

            if "pushToken" in form.cleaned_data and form.cleaned_data["pushToken"]:
                request.yoo["device"].device_token = form.cleaned_data["pushToken"]
                request.yoo["device"].save()

            if "referral" in form.cleaned_data and form.cleaned_data["referral"]:
                user.referral = form.cleaned_data["referral"]
                user.save()

            if user.tokens.filter(name="requestedEmail").exists():
                try:
                    CoinTicketGenericTransaction.objects.get(user=user, type="register")
                except CoinTicketGenericTransaction.DoesNotExist:
                    transaction = CoinTransaction(wallet=user.get_wallet())
                    transaction.save()

                    _coins = CoinTicketGenericTransaction(user=user, type="register", transaction=transaction)
                    _coins.save()

                    transaction.amount = _coins.amount
                    transaction.save()

            return self.get(request)
예제 #5
0
    def post(self, request):
        """
        Updates the details of the currently logged in user
        """
        # Short-Circuit for Authentication Errors caused by invalid Device IDs
	

	if request.yoo["new_version"]:
         if not request.yoo["user"] and request.yoo["auth"].get("__internal__reject__", False):
            raise exceptions.WebServiceAuthorizationFailed()
         user = request.yoo["user"]
         device = request.yoo["device"]
        
         try:
            data = json.loads(request.body)
         except:
            data = request.POST
            
         form = UserUpdateForm(data)
         if not form.is_valid():
            raise exceptions.WebServiceFormValidationFailed(form)

         email = form.cleaned_data["email"]
         password = form.cleaned_data["password"]
	        
         # Routing Logic        
         if email and password:
            self._modify_email(user, email, password)
         elif email:
            self._modify_email(user, email, password=None)
         elif password:
            self._modify_password(user, password)
        
         existing = dict([[x.name, x] for x in user.tokens.all()])
        
         for key in ["fbToken", "twitterToken", "contestEmail", "requestedEmail"]:
            if key not in data:
                continue
            
            if not form.cleaned_data[key]:
                if key in existing:
                    existing[key].delete()
            else:
                if key in existing:
                    existing[key].token = form.cleaned_data[key]
                else:
                    existing[key] = UserToken(user=user, name=key, token=form.cleaned_data[key])
            
                existing[key].save()
                
         if "pushToken" in form.cleaned_data and form.cleaned_data["pushToken"]:
            request.yoo["device"].device_token = form.cleaned_data["pushToken"]
            request.yoo["device"].save()
            
         if "referral" in form.cleaned_data and form.cleaned_data["referral"]:
            user.referral = form.cleaned_data["referral"]
            user.save()

         if email:
            try:
                coins_record, created = EmailCoins.objects.get_or_create(email=email,defaults={'coins': 0})
            except:
                coins_record = EmailCoins.objects.filter(email=email)[0]
            coins_record.save()

        
         if user.password and user.email or user.tokens.filter(name="requestedEmail").exists():
            try:
                CoinTicketGenericTransaction.objects.get(user=user, type="register")
            except CoinTicketGenericTransaction.DoesNotExist:
                transaction = CoinTransaction(wallet=user.get_wallet())
                transaction.save()
                
                _coins = CoinTicketGenericTransaction(user=user, type="register", transaction=transaction)
                _coins.save()
                                
                transaction.amount = _coins.amount
                transaction.save()
		try:
			device_record = DeviceCoins.objects.get(device_id=request.yoo['device'])
		except:
			device_record = DeviceCoins.objects.filter(device_id=request.yoo['device'])[0]
                device_record.coins = F('coins') + int(_coins.amount)
                device_record.save()

         try:
        	ClientLoginRecord, created = UserClientLogin.objects.get_or_create(device=request.yoo['device'], defaults={})
	 except:
		ClientLoginRecord  = UserClientLogin.objects.filter(device=request.yoo['device'])[0]
         if data.has_key('fbToken')  or data.has_key('twitterToken'):
            ClientLoginRecord.client_login = data['user_email']
         else:
            ClientLoginRecord.client_login = email
        # ClientLoginRecord.save()

         try:
            if created:
                token_info = UserToken.objects.filter(user_id = user.id)
                if token_info.name == "fbToken":
                    coins_record.coins = F('coins')+0.5
                    coins_record.save()
         except:
            pass


         
         return self.get(request)
        else:
	  
         # Short-Circuit for Authentication Errors caused by invalid Device IDs
         if not request.yoo["user"] and request.yoo["auth"].get("__internal__reject__", False):
            raise exceptions.WebServiceAuthorizationFailed()
        
         user = request.yoo["user"]
         device = request.yoo["device"]
        
         try:
            data = json.loads(request.body)
         except:
            data = request.POST
        
         form = UserUpdateForm(data)
         if not form.is_valid():
            raise exceptions.WebServiceFormValidationFailed(form)

         email = form.cleaned_data["email"]
         password = form.cleaned_data["password"]
                
         # Routing Logic        
         if email and password:
            self._modify_email(user, email, password)
         elif email:
            self._modify_email(user, email, password=None)
         elif password:
            self._modify_password(user, password)
        
         existing = dict([[x.name, x] for x in user.tokens.all()])
        
         for key in ["fbToken", "twitterToken", "contestEmail", "requestedEmail"]:
            if key not in data:
                continue
            
            if not form.cleaned_data[key]:
                if key in existing:
                    existing[key].delete()
            else:
                if key in existing:
                    existing[key].token = form.cleaned_data[key]
                else:
                    existing[key] = UserToken(user=user, name=key, token=form.cleaned_data[key])
            
                existing[key].save()
                
         if "pushToken" in form.cleaned_data and form.cleaned_data["pushToken"]:
            request.yoo["device"].device_token = form.cleaned_data["pushToken"]
            request.yoo["device"].save()
            
         if "referral" in form.cleaned_data and form.cleaned_data["referral"]:
            user.referral = form.cleaned_data["referral"]
            user.save()
        
         if user.tokens.filter(name="requestedEmail").exists():
            try:
                CoinTicketGenericTransaction.objects.get(user=user, type="register")
            except CoinTicketGenericTransaction.DoesNotExist:
                transaction = CoinTransaction(wallet=user.get_wallet())
                transaction.save()
                
                _coins = CoinTicketGenericTransaction(user=user, type="register", transaction=transaction)
                _coins.save()
                                
                transaction.amount = _coins.amount
                transaction.save()
        
         return self.get(request)