trex-model 1.6.3__tar.gz → 1.6.5__tar.gz

{trex_model-1.6.3 → trex_model-1.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trex_model
-Version: 1.6.3
+Version: 1.6.5
 Summary: TRex database module package
 Home-page: https://bitbucket.org/lokjac/trex-model
 Author: Jack Lok

{trex_model-1.6.3 → trex_model-1.6.5}/setup.py

@@ -3,7 +3,7 @@ with open("README.md", "r") as fh:
     long_description = fh.read()
 setuptools.setup(
      name='trex_model',  
-     version='1.6.3',
+     version='1.6.5',
      author="Jack Lok",
      author_email="sglok77@gmail.com",
      description="TRex database module package",

{trex_model-1.6.3 → trex_model-1.6.5}/trex_model.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trex-model
-Version: 1.6.3
+Version: 1.6.5
 Summary: TRex database module package
 Home-page: https://bitbucket.org/lokjac/trex-model
 Author: Jack Lok

{trex_model-1.6.3 → trex_model-1.6.5}/trexmodel/models/datastore/customer_models.py

@@ -87,6 +87,10 @@ class Customer(BaseNModel, DictModel, FullTextSearchable):
                            
                            ]
     
+    @property
+    def customer_key(self):
+        return self.key_in_str
+    
     @property
     def is_any_entitled_voucher_active(self):
         

{trex_model-1.6.3 → trex_model-1.6.5}/trexmodel/models/datastore/helper/reward_transaction_helper.py

@@ -25,8 +25,8 @@ from trexanalytics.bigquery_upstream_data_config import create_merchant_customer
     create_merchant_customer_prepaid_upstream_for_merchant,\
     create_merchant_customer_redemption_reverted_upstream_for_merchant,\
     create_revert_entitled_customer_voucher_upstream_for_merchant,\
-    create_entitled_customer_voucher_upstream_for_merchant,\
-    create_redeemed_customer_voucher_to_upstream_for_merchant
+    create_redeemed_customer_voucher_to_upstream_for_merchant,\
+    create_merchant_sales_transaction_upstream_for_merchant
 from trexmodel.models.datastore.membership_models import MerchantTierMembership
 from trexmodel.models.datastore.transaction_models import CustomerTransaction,\
     SalesTransaction
@@ -139,7 +139,7 @@ def create_sales_transaction(transact_outlet=None, sales_amount=.0, tax_amount=.
     logger.debug('invoice_details=%s', invoice_details)
     
     @model_transactional(desc='create_sales_transaction')
-    def __start_transaction_for_customer_transaction(): 
+    def __start_transaction_for_sales_transaction(): 
         sales_transaction = SalesTransaction.create(
                                        transact_outlet      = transact_outlet,
                                        
@@ -152,15 +152,14 @@ def create_sales_transaction(transact_outlet=None, sales_amount=.0, tax_amount=.
                                        transact_by          = transact_by,
                                        
                                        transact_datetime    = transact_datetime,
-                                       promotion_code       = promotion_code,
                                        
                                        )
             
-        #create_merchant_sales_transaction_upstream_for_merchant(sales_transaction, streamed_datetime=transact_datetime)
+        create_merchant_sales_transaction_upstream_for_merchant(sales_transaction,)
         
         return sales_transaction
         
-    return __start_transaction_for_customer_transaction()
+    return __start_transaction_for_sales_transaction()
 
 def create_reward_transaction(customer, transact_outlet=None, sales_amount=.0, tax_amount=.0, invoice_id=None, remarks=None, 
                             transact_by=None, transact_datetime=None, invoice_details=None, promotion_code=None):
@@ -171,6 +170,25 @@ def create_reward_transaction(customer, transact_outlet=None, sales_amount=.0, t
     
     @model_transactional(desc='create_reward_transaction')
     def __start_transaction_for_customer_transaction():
+        
+        sales_transaction = SalesTransaction.create(
+                                       transact_outlet      = transact_outlet,
+                                       
+                                       transact_amount      = sales_amount, 
+                                       tax_amount           = tax_amount,
+                                       
+                                       invoice_id           = invoice_id, 
+                                       remarks              = remarks,
+                                       
+                                       transact_by          = transact_by,
+                                       
+                                       transact_datetime    = transact_datetime,
+                                       
+                                       )
+        create_merchant_sales_transaction_upstream_for_merchant(sales_transaction)
+        
+        #customer_transaction = give_reward_from_sales_transaction(customer, sales_transaction)
+        
         customer_transaction = CustomerTransaction.create_system_transaction(
                                        customer, 
                                        transact_outlet      = transact_outlet,
@@ -196,7 +214,8 @@ def create_reward_transaction(customer, transact_outlet=None, sales_amount=.0, t
         
         if trigger_check_reward_success:
             create_transaction_message(customer_transaction)
-            create_merchant_customer_transaction_upstream_for_merchant(customer_transaction, streamed_datetime=transact_datetime)
+            create_merchant_customer_transaction_upstream_for_merchant(customer_transaction, )
+        
         
         return customer_transaction
         
@@ -216,7 +235,7 @@ def give_reward_from_sales_transaction(customer, sales_transaction, for_testing=
             
             if trigger_check_reward_success:
                 create_transaction_message(customer_transaction)
-                create_merchant_customer_transaction_upstream_for_merchant(customer_transaction, streamed_datetime=sales_transaction.transact_datetime)
+                create_merchant_customer_transaction_upstream_for_merchant(customer_transaction,)
         
         return customer_transaction
     
@@ -389,12 +408,12 @@ def check_for_tier_membership_upgrade_downgrade(customer_acct, merchant_acct, tr
         existing_tier_membership        = None
         membership_to_assign            = None
         
-        customer_kpi_summary            = customer_acct.kpi_summary
+        customer_kpi_summary            = customer_acct.kpi_summary or {}
         
-        total_transact_amount           = customer_kpi_summary['total_transact_amount']
-        total_accumulated_point         = customer_kpi_summary['total_accumulated_point']
-        total_accumulated_stamp         = customer_kpi_summary['total_accumulated_stamp'] 
-        total_accumulated_prepaid       = customer_kpi_summary['total_accumulated_prepaid']
+        total_transact_amount           = customer_kpi_summary.get('total_transact_amount',0)
+        total_accumulated_point         = customer_kpi_summary.get('total_accumulated_point',0)
+        total_accumulated_stamp         = customer_kpi_summary.get('total_accumulated_stamp',0) 
+        total_accumulated_prepaid       = customer_kpi_summary.get('total_accumulated_prepaid',0)
         
         logger.debug('check_for_tier_membership_upgrade_downgrade: total_transact_amount=%s', total_transact_amount)
         logger.debug('check_for_tier_membership_upgrade_downgrade: total_accumulated_point=%s', total_accumulated_point)
@@ -712,7 +731,7 @@ def redeem_reward_transaction(customer, redeem_outlet=None, reward_format=None,
             
             if customer_redemption:
                 create_redemption_message(customer_redemption)
-                create_merchant_customer_redemption_upstream_for_merchant(customer_redemption, streamed_datetime=redeemed_datetime)
+                create_merchant_customer_redemption_upstream_for_merchant(customer_redemption, )
                 if reward_format == program_conf.REWARD_FORMAT_VOUCHER:
                     for voucher_key in redeemed_voucher_keys_list:
                         customer_voucher        = CustomerEntitledVoucher.fetch(voucher_key)
@@ -752,7 +771,7 @@ def prepaid_payment_transaction(customer, redeem_outlet=None, reward_format=None
             
             if customer_redemption:
                 create_payment_message(customer_redemption)
-                create_merchant_customer_redemption_upstream_for_merchant(customer_redemption, streamed_datetime=redeemed_datetime)
+                create_merchant_customer_redemption_upstream_for_merchant(customer_redemption, )
             
             return customer_redemption
             
@@ -920,6 +939,21 @@ def revert_transaction(transaction_details, reverted_by, reverted_datetime=None,
             transaction_details.reverted_by_username       = reverted_by.username
             transaction_details.put()
             
+            create_merchant_customer_transaction_upstream_for_merchant(transaction_details, Reverted=True)
+            
+            if transaction_details.is_sales_transaction:
+                sales_transaction = SalesTransaction.get_by_transaction_id(transaction_id)
+                
+                if sales_transaction:
+                    sales_transaction.is_revert                  = True
+                    sales_transaction.reverted_datetime          = reverted_datetime
+                    sales_transaction.reverted_by                = reverted_by_key
+                    sales_transaction.reverted_by_username       = reverted_by.username
+                    sales_transaction.put()
+                    
+                    create_merchant_sales_transaction_upstream_for_merchant(sales_transaction, Reverted=True)
+                
+            
             if is_stamp_entitled_in_transaction or is_point_entitled_in_transaction or is_voucher_entitled_in_transaction or is_prepaid_entitled_in_transaction:
                 for p in reverting_point_details_list:
                     if p.is_valid:
@@ -1163,8 +1197,8 @@ def create_topup_prepaid_transaction(customer, prepaid_program, topup_outlet=Non
             update_customer_kpi_summary_and_transact_summary(customer, customer_transaction)
             
             create_transaction_message(customer_transaction)
-            create_merchant_customer_prepaid_upstream_for_merchant(customer_transaction, prepaid_topup_reward, streamed_datetime=transact_datetime)
-            create_merchant_customer_transaction_upstream_for_merchant(customer_transaction, streamed_datetime=transact_datetime)
+            create_merchant_customer_prepaid_upstream_for_merchant(customer_transaction, prepaid_topup_reward, )
+            create_merchant_customer_transaction_upstream_for_merchant(customer_transaction, )
         
         return (customer_transaction, prepaid_summary)
         

{trex_model-1.6.3 → trex_model-1.6.5}/trexmodel/models/datastore/lucky_draw_models.py

@@ -16,6 +16,7 @@ import random
 from trexlib.utils.common.common_util import sort_dict_list
 from trexmodel.models.datastore.customer_models import Customer
 from collections import Counter
+from trexmodel.models.datastore.voucher_models import MerchantVoucher
 
 logger = logging.getLogger('model')
 #logger = logging.getLogger('debug')
@@ -678,15 +679,27 @@ class LuckyDrawTicket(BaseNModel, DictModel):
         program = LuckyDrawTicket.__get_lucky_draw_program(merchant_acct.lucky_draw_configuration, customer_acct=customer_acct)
         if program:            
             program_key = program.get('program_key')
-            prize_details_list  = program.get('program_settings').get('prize_settings').get('prizes')
-            ticket_image_url    = program.get('program_settings').get('ticket_image_url')
-            
+            prize_details_list      = program.get('program_settings').get('prize_settings').get('prizes')
+            ticket_image_url        = program.get('program_settings').get('ticket_image_url')
+            archived_vouchers_list  = MerchantVoucher.list_archived_by_merchant_account(merchant_acct)
             for prize in prize_details_list:
                 if prize.get('prize_type') == program_conf.REWARD_FORMAT_VOUCHER:
+                    found_voucher = False
                     for voucher_details in merchant_acct.published_voucher_configuration.get('vouchers'):
                         if voucher_details.get('voucher_key') == prize.get('voucher_key'):
                             prize['image_url']  = voucher_details.get('image_url')
                             prize['label']      = voucher_details.get('label')
+                            found_voucher = True
+                    
+                    if found_voucher==False:
+                        logger.info('Some voucher may be archived')
+                        
+                        if archived_vouchers_list:
+                            for voucher_details in archived_vouchers_list:
+                                if voucher_details.key_in_str == prize.get('voucher_key'):
+                                    prize['image_url']  = voucher_details.image_public_url
+                                    prize['label']      = voucher_details.label
+                                    found_voucher = True
                             
             
             drawed_details =  {

{trex_model-1.6.3 → trex_model-1.6.5}/trexmodel/models/datastore/ndb_models.py

@@ -18,8 +18,8 @@ from trexconf import conf as model_conf
 from google.cloud.datastore.helpers import GeoPoint
 from trexlib.utils.common.cache_util import getFromCache, setCache
  
-#logger = logging.getLogger('model')
-logger = logging.getLogger('target_debug') 
+logger = logging.getLogger('model')
+#logger = logging.getLogger('target_debug') 
 
 def clone_entity(entity, parent=None, **extra_args):
     """

{trex_model-1.6.3 → trex_model-1.6.5}/trexmodel/models/datastore/reward_models.py

@@ -396,7 +396,7 @@ class CustomerEntitledVoucher(CustomerEntitledReward):
     
     dict_properties     = [
                             'redeem_code', 'configuration', 'rewarded_datetime', 'transaction_id', 
-                            'status', 'is_reverted', 'is_used', 'is_partnership_voucher', 'partner_merchant_acct_key',
+                            'status', 'is_reverted', 'is_used', 'partner_merchant_acct_key',
                            ]
     
     @property
@@ -430,6 +430,21 @@ class CustomerEntitledVoucher(CustomerEntitledReward):
         
         return result
     
+    @staticmethod
+    def list_by_merchant_voucher(merchant_voucher, entitled_datetime_start=None, entitled_datetime_end=None):
+        if entitled_datetime_start and entitled_datetime_end:
+            result = CustomerEntitledVoucher.query(ndb.AND(
+                        CustomerEntitledVoucher.entitled_voucher==merchant_voucher.create_ndb_key(),
+                        CustomerEntitledVoucher.rewarded_datetime>=entitled_datetime_start,
+                        CustomerEntitledVoucher.rewarded_datetime<entitled_datetime_end,
+                        )).fetch(limit=conf.MAX_FETCH_RECORD)
+        else:
+            result = CustomerEntitledVoucher.query(ndb.AND(
+                        CustomerEntitledVoucher.entitled_voucher==merchant_voucher.create_ndb_key(),
+                        )).fetch(limit=conf.MAX_FETCH_RECORD)
+        
+        return result
+    
     @staticmethod
     def count_redeemed_by_merchant_voucher(customer, merchant_voucher, passed_day_count=1):
         
@@ -506,6 +521,16 @@ class CustomerEntitledVoucher(CustomerEntitledReward):
         
         return result
     
+    @staticmethod
+    def count_merchant_voucher(merchant_voucher):
+        
+        result = CustomerEntitledVoucher.query(ndb.AND(
+                    CustomerEntitledVoucher.entitled_voucher==merchant_voucher.create_ndb_key(),
+                    )).count(limit=conf.MAX_FETCH_RECORD)
+    
+        
+        return result
+    
     def revert_from_redemption(self):
         self.status = program_conf.REDEEM_STATUS_VALID
         self.redeemed_datetime      = None

{trex_model-1.6.3 → trex_model-1.6.5}/trexmodel/models/datastore/transaction_models.py

@@ -19,7 +19,8 @@ from trexmodel.utils.model.model_util import generate_transaction_id
 from trexmodel.models.datastore.membership_models import MerchantMembership,\
     MerchantTierMembership
 
-logger = logging.getLogger('model')
+#logger = logging.getLogger('model')
+logger = logging.getLogger('target_debug')
 
 class SalesTransaction(BaseNModel, DictModel):
     transact_merchant           = ndb.KeyProperty(name="transact_merchant", kind=MerchantAcct)
@@ -93,11 +94,11 @@ class SalesTransaction(BaseNModel, DictModel):
     @property
     def transact_by_user(self):
         if self.transact_by:
-            return MerchantUser.fetch(self.transact_by.urlsafe())
+            return self.transact_by.get()
         
     @property
     def transact_by_user_acct_key(self):
-        return self.transact_by.urlsafe()
+        return self.transact_by.urlsafe().decode('utf-8')
         
     @property
     def after_deduct_tax_sales_amount(self):
@@ -124,8 +125,9 @@ class SalesTransaction(BaseNModel, DictModel):
     
     @staticmethod
     def create(transact_amount=.0, tax_amount=.0, invoice_id=None, remarks=None, system_remarks=None,
-               transact_outlet=None, transact_by=None, transact_datetime=None, 
-               
+               transact_outlet=None, transact_by=None, transact_datetime=None, transaction_id=None,
+               allow_to_revert = True, is_revert=False, reverted_datetime=None, reverted_by=None, reverted_by_username=None,
+               sales_channel=None, created_datetime=None,
                ):
         
         transact_by_username = None
@@ -134,8 +136,8 @@ class SalesTransaction(BaseNModel, DictModel):
             if isinstance(transact_by, MerchantUser):
                 transact_by_username = transact_by.username
 
-        
-        transaction_id = generate_transaction_id()
+        if transaction_id is None:
+            transaction_id = generate_transaction_id()
         
         if transact_datetime is None:
             transact_datetime = datetime.utcnow()
@@ -166,8 +168,16 @@ class SalesTransaction(BaseNModel, DictModel):
                                 transact_datetime               = transact_datetime,
                                 
                                 is_sales_transaction            = True,
-                                allow_to_revert                 = True,
+                                allow_to_revert                 = allow_to_revert,
+                                
+                                is_revert                       = is_revert,
+                                reverted_datetime               = reverted_datetime,
+                                reverted_by                     = reverted_by,
+                                reverted_by_username            = reverted_by_username,
                                 
+                                sales_channel                   = sales_channel,
+                                
+                                created_datetime                = created_datetime,
                                 )
         
         customer_transaction.put()
@@ -175,7 +185,130 @@ class SalesTransaction(BaseNModel, DictModel):
         
         return customer_transaction
     
+    @classmethod
+    def list_outlet_transaction(cls, transact_outlet, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True):
+        if reverse_order:
+            query = cls.query(ndb.AND(cls.transact_outlet==transact_outlet.create_ndb_key())).order(-cls.transact_datetime)
+        else:
+            query = cls.query(ndb.AND(cls.transact_outlet==transact_outlet.create_ndb_key())).order(cls.transact_datetime)
+        
+        return cls.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
+    
+    @classmethod
+    def count_outlet_transaction(cls, transact_outlet, limit=conf.MAX_FETCH_RECORD):
+        query = cls.query(ndb.AND(cls.transact_outlet==transact_outlet.create_ndb_key()))
+        
+        return   cls.count_with_condition_query(query, limit=limit)
+    
+    
+    @classmethod
+    def list_merchant_transaction(cls, transact_merchant, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True):
+        if reverse_order:
+            query = cls.query(ndb.AND(cls.transact_merchant==transact_merchant.create_ndb_key()))
+        else:
+            query = cls.query(ndb.AND(cls.transact_merchant==transact_merchant.create_ndb_key()))
+        
+        return cls.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
+    
+    @classmethod
+    def count_by_merchant(cls, transact_merchant, limit=conf.MAX_FETCH_RECORD):
+        query = cls.query(ndb.AND(cls.transact_merchant==transact_merchant.create_ndb_key()))
+        
+        return cls.count_with_condition_query(query, limit)
+    
+    @classmethod
+    def list(cls, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True):
+        if reverse_order:
+            query = cls.query().order(-cls.transact_datetime)
+        else:
+            query = cls.query().order(cls.transact_datetime)
+        
+        return cls.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
+    
+    @classmethod
+    def list_transaction_by_date(cls, transact_date, transact_outlet=None, including_reverted_transaction=True, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False):
+        
+        transact_datetime           = datetime.combine(transact_date, datetime.min.time())
+        next_day_transact_datetime  = transact_datetime + timedelta(days=1)
+        
+        logger.debug('transact_datetime=%s',transact_datetime)
+        logger.debug('next_day_transact_datetime=%s',next_day_transact_datetime)
+        logger.debug('including_reverted_transaction=%s',including_reverted_transaction)
+        logger.debug('limit=%s',limit)
+        
+        if transact_outlet:
+            if including_reverted_transaction:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    cls.transact_outlet == transact_outlet.create_ndb_key(),
+                                    )).order(-cls.transact_datetime)
+            else:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    cls.transact_outlet == transact_outlet.create_ndb_key(),
+                                    cls.is_revert == False,
+                                    )).order(-cls.transact_datetime)
+        else:
+            if including_reverted_transaction:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    )).order(-cls.transact_datetime)
+            else:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    cls.is_revert == False,
+                                    )).order(-cls.transact_datetime)
+        
+        return cls.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
+    @classmethod
+    def count_merchant_transaction(cls, merchant_acct, limit=conf.MAX_FETCH_RECORD):
+        query = cls.query(ndb.AND(CustomerTransaction.transact_merchant==merchant_acct.create_ndb_key()))
+        
+        return CustomerTransaction.count_with_condition_query(query, limit=limit)
+    
+    @classmethod
+    def count_transaction_by_date(cls, transact_date, including_reverted_transaction=False, transact_outlet=None, limit=conf.MAX_FETCH_RECORD):
+        
+        transact_datetime           = datetime.combine(transact_date, datetime.min.time())
+        next_day_transact_datetime  = transact_datetime + timedelta(days=1)
         
+        logger.debug('transact_datetime=%s',transact_datetime)
+        logger.debug('next_day_transact_datetime=%s',next_day_transact_datetime)
+        logger.debug('including_reverted_transaction=%s',including_reverted_transaction)
+        
+        if transact_outlet:
+            if including_reverted_transaction:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    cls.transact_outlet == transact_outlet.create_ndb_key()
+                                    ))
+            else:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    cls.transact_outlet == transact_outlet.create_ndb_key(),
+                                    cls.is_revert == False,
+                                    ))
+        else:
+            if including_reverted_transaction:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    ))
+            else:
+                query = cls.query(ndb.AND(
+                                    cls.transact_datetime  >= transact_datetime,
+                                    cls.transact_datetime  <  next_day_transact_datetime,
+                                    cls.is_revert == False,
+                                    ))
+        
+        return cls.count_with_condition_query(query, limit=limit)
+    
     
 class CustomerTransaction(SalesTransaction):
     '''
@@ -249,7 +382,8 @@ class CustomerTransaction(SalesTransaction):
     
     @property
     def transact_customer_acct(self):
-        return Customer.fetch(self.key.parent().urlsafe())
+        #return Customer.fetch(self.key.parent().urlsafe())
+        return self.key.parent().get()
     
     @property
     def transact_user_acct(self):
@@ -266,7 +400,12 @@ class CustomerTransaction(SalesTransaction):
     @property
     def transact_outlet_details(self):
         if self.transact_outlet:
-            return Outlet.fetch(self.transact_outlet.urlsafe())
+            return self.transact_outlet.get()
+        
+    @property
+    def transact_by_entity(self):
+        if self.transact_by:
+            return self.transact_by.get()    
     
     @property
     def transact_outlet_name(self):
@@ -388,9 +527,9 @@ class CustomerTransaction(SalesTransaction):
                                                         
                                                         transact_datetime               = sales_transaction.transact_datetime,
                                                         is_from_instant_transaction     = True,
-                                                        is_rating_review_enabled        = is_rating_review_enabled
+                                                        is_rating_review_enabled        = is_rating_review_enabled,
                                                         #is_sales_transaction            = True,
-                                                        #allow_to_revert                 = True,
+                                                        allow_to_revert                 = False,
                                                         #is_membership_purchase          = False,
                                                         #is_membership_renew             = False,
                                                         #purchased_merchant_membership   = False,
@@ -466,105 +605,7 @@ class CustomerTransaction(SalesTransaction):
         #customer.put()
         
         return customer_transaction
-    '''
-    def revert(self, customer_acct, reverted_by):
-        transaction_id = self.transaction_id
-        
-        entitled_point_details_list     = CustomerPointReward.list_by_transaction_id(transaction_id)
-        
-        entitled_stamp_details_list     = CustomerStampReward.list_by_transaction_id(transaction_id)
-        
-        entiteld_vouchers_list          = CustomerEntitledVoucher.list_by_transaction_id(transaction_id)
-        
-        entitled_prepaid_list           = CustomerPrepaidReward.list_by_transaction_id(transaction_id)
-        
-        is_transaction_reward_used      = False
-        
-        customer_reward_summary     = customer_acct.reward_summary or {}
-        entitled_voucher_summary    = customer_acct.entitled_voucher_summary or {}
-        
-        logger.debug('revert: transaction_id=%s', transaction_id)
-        logger.debug('revert: entitled_point_details_list count=%s', len(entitled_point_details_list))
-        logger.debug('revert: entitled_stamp_details_list count=%s', len(entitled_stamp_details_list))
-        logger.debug('revert: entiteld_vouchers_list count=%s', len(entiteld_vouchers_list))
-        
-        for p in entitled_point_details_list:
-            if p.is_used:
-                is_transaction_reward_used = True
-                break
-        
-        if is_transaction_reward_used is False:
-            for p in entitled_stamp_details_list:
-                if p.is_used:
-                    is_transaction_reward_used = True
-                    break
-                
-        if is_transaction_reward_used is False:
-            for p in entiteld_vouchers_list:
-                if p.is_used:
-                    is_transaction_reward_used = True
-                    break
-        
-        logger.debug('revert: is_transaction_reward_used=%s', is_transaction_reward_used)
-        
-        if is_transaction_reward_used is False:
-            
-            logger.debug('Going to revert transqction')
-            reverted_by_key                 = reverted_by.create_ndb_key()
-            
-            reverted_datetime               = datetime.now()
-            self.is_revert                  = True
-            self.reverted_datetime          = reverted_datetime
-            self.reverted_by                = reverted_by_key
-            self.reverted_by_username       = reverted_by.username
-            self.put()
-            
-            for p in entitled_point_details_list:
-                if p.is_valid:
-                    customer_reward_summary = update_reward_summary_with_reverted_reward(customer_reward_summary, p.to_reward_summary())
-                    p.status                        = program_conf.REWARD_STATUS_REVERTED
-                    p.reverted_datetime             = reverted_datetime
-                    p.reverted_by                   = reverted_by_key
-                    p.reverted_by_username          = reverted_by.username
-                    p.put()
-                    
-                
-            for p in entitled_stamp_details_list:
-                if p.is_valid:
-                    customer_reward_summary = update_reward_summary_with_reverted_reward(customer_reward_summary, p.to_reward_summary())
-                    p.status                        = program_conf.REWARD_STATUS_REVERTED
-                    p.reverted_datetime             = reverted_datetime
-                    p.reverted_by                   = reverted_by_key
-                    p.reverted_by_username          = reverted_by.username
-                    p.put()
-                
-            for p in entiteld_vouchers_list:
-                if p.is_valid:
-                    p.status                        = program_conf.REWARD_STATUS_REVERTED
-                    p.reverted_datetime             = reverted_datetime
-                    p.reverted_by                   = reverted_by_key
-                    p.reverted_by_username          = reverted_by.username
-                    p.put()
-                    
-                    entitled_voucher_summary = update_customer_entiteld_voucher_summary_after_reverted_voucher(entitled_voucher_summary, p)
-            
-            updated_voucher_summary = {}
-            
-            logger.debug('revert transaction debug: entitled_voucher_summary=%s', entitled_voucher_summary)
-            
-            for voucher_key, details in entitled_voucher_summary.items():
-                if len(details.get('redeem_info_list'))>0:
-                    updated_voucher_summary[voucher_key] = details
-                
-            customer_acct.reward_summary            = customer_reward_summary
-            customer_acct.entitled_voucher_summary  = updated_voucher_summary or {}
-            customer_acct.put()
-            
-            return True
-        
-        else:
-            raise Exception('Transaction reward have been used')
-    '''
+    
     @staticmethod
     def list_customer_transaction(customer_acct, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True, keys_only=False):
         if keys_only:
@@ -583,45 +624,12 @@ class CustomerTransaction(SalesTransaction):
         query = CustomerTransaction.query(ancestor = customer_acct.create_ndb_key())
         CustomerTransaction.delete_multiples(query)
     
-    @staticmethod
-    def list(offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True):
-        if reverse_order:
-            query = CustomerTransaction.query().order(-CustomerTransaction.transact_datetime)
-        else:
-            query = CustomerTransaction.query().order(CustomerTransaction.transact_datetime)
-        
-        return CustomerTransaction.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
-    
-    @staticmethod
-    def list_outlet_transaction(transact_outlet, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True):
-        if reverse_order:
-            query = CustomerTransaction.query(ndb.AND(CustomerTransaction.transact_outlet==transact_outlet.create_ndb_key())).order(-CustomerTransaction.transact_datetime)
-        else:
-            query = CustomerTransaction.query(ndb.AND(CustomerTransaction.transact_outlet==transact_outlet.create_ndb_key())).order(CustomerTransaction.transact_datetime)
-        
-        return CustomerTransaction.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
-    
-    @staticmethod
-    def list_merchant_transaction(transact_merchant, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False, reverse_order=True):
-        if reverse_order:
-            query = CustomerTransaction.query(ndb.AND(CustomerTransaction.transact_merchant==transact_merchant.create_ndb_key()))
-        else:
-            query = CustomerTransaction.query(ndb.AND(CustomerTransaction.transact_merchant==transact_merchant.create_ndb_key()))
-        
-        return CustomerTransaction.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
-    
     @staticmethod
     def count_valid_customer_transaction(customer_acct, limit=conf.MAX_FETCH_RECORD):
         query = CustomerTransaction.query(ndb.AND(CustomerTransaction.is_revert==False), ancestor = customer_acct.create_ndb_key())
         
         return   CustomerTransaction.count_with_condition_query(query, limit=limit)
     
-    @staticmethod
-    def count_outlet_transaction(transact_outlet, limit=conf.MAX_FETCH_RECORD):
-        query = CustomerTransaction.query(ndb.AND(CustomerTransaction.transact_outlet==transact_outlet.create_ndb_key()))
-        
-        return   CustomerTransaction.count_with_condition_query(query, limit=limit)
-    
     @staticmethod
     def list_valid_customer_transaction(customer_acct, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False):
         
@@ -653,43 +661,7 @@ class CustomerTransaction(SalesTransaction):
     def get_by_transaction_id(transaction_id):
         return CustomerTransaction.query(CustomerTransaction.transaction_id==transaction_id).get()
     
-    @staticmethod
-    def list_transaction_by_date(transact_date, transact_outlet=None, including_reverted_transaction=True, offset=0, limit=conf.PAGINATION_SIZE, start_cursor=None, return_with_cursor=False):
-        
-        transact_datetime           = datetime.combine(transact_date, datetime.min.time())
-        next_day_transact_datetime  = transact_datetime + timedelta(days=1)
-        
-        logger.debug('transact_datetime=%s',transact_datetime)
-        logger.debug('next_day_transact_datetime=%s',next_day_transact_datetime)
-        
-        if transact_outlet:
-            if including_reverted_transaction:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    CustomerTransaction.transact_outlet == transact_outlet.create_ndb_key(),
-                                    )).order(-CustomerTransaction.transact_datetime)
-            else:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    CustomerTransaction.transact_outlet == transact_outlet.create_ndb_key(),
-                                    CustomerTransaction.is_revert == False,
-                                    )).order(-CustomerTransaction.transact_datetime)
-        else:
-            if including_reverted_transaction:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    )).order(-CustomerTransaction.transact_datetime)
-            else:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    CustomerTransaction.is_revert == False,
-                                    )).order(-CustomerTransaction.transact_datetime)
-        
-        return CustomerTransaction.list_all_with_condition_query(query, offset=offset, limit=limit, start_cursor=start_cursor, return_with_cursor=return_with_cursor)
+    
     
     @staticmethod
     def list_all(offset=0, limit=conf.MAX_FETCH_RECORD):
@@ -704,49 +676,7 @@ class CustomerTransaction(SalesTransaction):
         
         return CustomerTransaction.count_with_condition_query(query, limit=limit)
     
-    @staticmethod
-    def count_merchant_transaction(merchant_acct, limit=conf.MAX_FETCH_RECORD):
-        query = CustomerTransaction.query(ndb.AND(CustomerTransaction.transact_merchant==merchant_acct.create_ndb_key()))
-        
-        return CustomerTransaction.count_with_condition_query(query, limit=limit)
     
-    @staticmethod
-    def count_transaction_by_date(transact_date, including_reverted_transaction=True, transact_outlet=None, limit=conf.MAX_FETCH_RECORD):
-        
-        transact_datetime           = datetime.combine(transact_date, datetime.min.time())
-        next_day_transact_datetime  = transact_datetime + timedelta(days=1)
-        
-        logger.debug('transact_datetime=%s',transact_datetime)
-        logger.debug('next_day_transact_datetime=%s',next_day_transact_datetime)
-        
-        if transact_outlet:
-            if including_reverted_transaction:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    CustomerTransaction.transact_outlet == transact_outlet.create_ndb_key()
-                                    ))
-            else:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    CustomerTransaction.transact_outlet == transact_outlet.create_ndb_key(),
-                                    CustomerTransaction.is_revert == False,
-                                    ))
-        else:
-            if including_reverted_transaction:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    ))
-            else:
-                query = CustomerTransaction.query(ndb.AND(
-                                    CustomerTransaction.transact_datetime  >= transact_datetime,
-                                    CustomerTransaction.transact_datetime  <  next_day_transact_datetime,
-                                    CustomerTransaction.is_revert == False,
-                                    ))
-        
-        return CustomerTransaction.count_with_condition_query(query, limit=limit)