3 type of promotion test pass

apps/promotions/models.py

@@ -139,7 +139,8 @@ class Recipient(BaseModel):
         return self.wallet_uuid or settings.WALLET_PROMOTION_CATEGORY_UUID
 
     def get_recipient_uuid(self, plan=None, event=None):
-        try:
+        if ':' in self.recipient_uuid_field and not self.recipient_uuid_field.startswith('QS:'):
+
             model_name, key = self.recipient_uuid_field.split(':')
             if model_name == 'event':
                 obj = event
@@ -149,7 +150,27 @@ class Recipient(BaseModel):
                 raise NotImplementedError()
 
             return obj.data.get(key)
-        except Exception as e:
+        elif ':' in self.recipient_uuid_field and self.recipient_uuid_field.startswith('QS:'):
+            params , recipient_candidate = self.recipient_uuid_field.split('->')
+            query_set_flag, model, filters,  = params.split(':')
+            filters_key_values= filters.split('&')
+            filter_params = {}
+            for key_value in filters_key_values:
+                key, value = key_value.split('=')
+                filter_params[key] = value
+            if model.lower() == 'event':
+                model_class = Event
+            elif model.lower() == 'plan':
+                model_class = Plan
+            elif model.lower() == 'promotion':
+                model_class = Promotion
+            else:
+                raise NotImplementedError()
+
+            if model_class.objects.filter(**filter_params).exists():
+                return recipient_candidate
+
+        else:
             try:
                 uuid.UUID(self.recipient_uuid_field)
                 return self.recipient_uuid_field
@@ -182,26 +203,29 @@ class Recipient(BaseModel):
     #     return PromotionTypeChoices(self.promotion_type).handler(self)
 
     def promote(self, plan=None, event=None):
-        with transaction.atomic():
+        recipient = self.get_recipient_uuid(plan, event)
-            promotion_amount = self.get_promotion_amount(plan=plan, event=event)
+        if recipient:
-            reserved = self.plan.reserve_promotion_amount(promotion_amount)
+            with transaction.atomic():
-            if reserved:
+                promotion_amount = self.get_promotion_amount(plan=plan, event=event)
-                promotion, created = Promotion.objects.get_or_create(
+                reserved = self.plan.reserve_promotion_amount(promotion_amount)
-                    promotion_amount=promotion_amount,
+                if reserved:
-                    user_uuid=self.get_recipient_uuid(plan, event),
+                    promotion, created = Promotion.objects.get_or_create(
-                    event=event,
+                        promotion_amount=promotion_amount,
-                    plan=plan,
+                        user_uuid=self.get_recipient_uuid(plan, event),
-                    recipient=self,
+                        event=event,
-                    base_amount=promotion_amount,
+                        plan=plan,
-                )
+                        recipient=self,
-                if created:
+                        base_amount=promotion_amount,
-                    promotion.promote()
+                    )
+                    if created:
+                        promotion.promote()
+                    else:
+                        raise Exception('promotion object not created')
                 else:
-                    raise Exception('promotion object not created')
+                    raise Exception('promotion reward not reserved')
-            else:
-                raise Exception('promotion reward not reserved')
 
-        return promotion
+            return promotion
+        return None
 
 
 class PromotionQuerySet(models.QuerySet):

apps/promotions/tests.py

@@ -216,48 +216,66 @@ class ApplicationApiFlowsTests(APITestCase):
         self.assertEqual(response.json()['promotions'][0]['user'], str(self.user_2_uuid))
 
 
-    def test_referral_reward_submit_event_success(self):
+    def test_referral_reward_submit_settlement_success(self):
         self.referral_reward_event_saver, _created = EventSaver.objects.get_or_create(
             title=self.referral_reward_label,
             event_label=self.referral_reward_label,
             save_once=True,
         )
 
-        self.referral_reward_plan, _created = Plan.objects.get_or_create(
+        self.settlement_reward_event_saver, _created = EventSaver.objects.get_or_create(
-            title=self.referral_reward_label,
+            title=self.settlement_reward_label,
-            balance=10000,
+            event_label=self.settlement_reward_label,
-            user=self.user_1,
+            save_once=False,
-            application=self.application,
-            event_list=[self.referral_reward_label]
         )
 
-        self.referral_reward_recipient, _created = Recipient.objects.get_or_create(
+        self.settlement_reward_plan, _created = Plan.objects.get_or_create(
-            label=self.referral_reward_label,
+            title=self.settlement_reward_label,
-            plan=self.referral_reward_plan,
+            balance=100000,
+            user=self.user_1,
+            application=self.application,
+            event_list=[self.settlement_reward_label]
+        )
+
+        self.settlement_referral_reward_recipient, _created = Recipient.objects.get_or_create(
+            label='settlement_referral_reward_label',
+            plan=self.settlement_reward_plan,
             wallet_uuid=self.user_1_uuid,
-            recipient_uuid_field="event:referral",
+            # recipient_uuid_field=self.user_2_uuid,
-            base_amount_field="1000",
+            recipient_uuid_field=f"QS:Event:label={self.referral_reward_label}&data__referral={self.user_2_uuid}->{self.user_2_uuid}",
+            base_amount_field="event:base_amount",
 
         )
 
         auth = self._create_authorization_header(self.user_access_token.token)
-        event_create_data = {
+        submit_referral_create_data = {
             'label': self.referral_reward_label,
             "data": {
                 'user': self.user_1_uuid,
                 'referral': self.user_2_uuid
             }
         }
+        submit_settlement_create_data = {
+            'label': self.settlement_reward_label,
+            "data": {
+                'user': self.user_1_uuid,
+                'settlement': self.user_2_uuid,
+                'base_amount': 7000
+            }
+        }
         self.assertEqual(Event.objects.count(), 0)
-        response = self.client.post(reverse('promotions:event'), event_create_data, HTTP_AUTHORIZATION=auth, format='json')
+        response = self.client.post(reverse('promotions:event'), submit_referral_create_data, HTTP_AUTHORIZATION=auth, format='json')
         print(response.json())
-        self.referral_reward_plan.refresh_from_db()
+        self.settlement_reward_plan.refresh_from_db()
-        self.assertEqual(self.referral_reward_plan.balance, 10000)
+        self.assertEqual(self.settlement_reward_plan.balance, 100000)
         self.assertEqual(Event.objects.count(), 1)
-        event = Event.objects.first()
+
-        analyze_event_task(event.uuid)
+        response = self.client.post(reverse('promotions:promote', kwargs={'plan': str(self.settlement_reward_plan.uuid)}), submit_settlement_create_data, HTTP_AUTHORIZATION=auth, format='json')
-        self.referral_reward_plan.refresh_from_db()
+        print(response.json())
-        self.assertEqual(self.referral_reward_plan.balance, 10000 - 1000)
+        response = self.client.post(reverse('promotions:promote', kwargs={'plan': str(self.settlement_reward_plan.uuid)}), submit_settlement_create_data, HTTP_AUTHORIZATION=auth, format='json')
+        print(response.json())
+
+