WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/model/v1/order/impl/DataAccessors.py

     AmazonFCWarehouseLocation, RechargeMode, CreditTxnType, \
     CreditHistory as TCreditHistory, LoanHistory as TLoanHistory, \
     ShipmentLogisticsCostDetail as TShipmentLogisticsCostDetail, \
     ReturnTransactionStatus, ReturnAction, ReturnTxnResolutionStatus, \
     ReplacementShippingType, ReturnTxnPickupStatus, ReceivedReturnType, \
-    ReturnPickupType, RefundType, SellerInfo, BuyerInfo
+    ReturnPickupType, RefundType, SellerInfo, BuyerInfo, WalletReferenceType
 from shop2020.thriftpy.model.v1.user.ttypes import VoucherType, CouponCategory, \
     User, Sex
 from shop2020.thriftpy.payments.ttypes import PaymentException
 from shop2020.thriftpy.utils.ttypes import UserSmsInfo, SmsType
 from shop2020.thriftpy.warehouse.ttypes import ScanType, \
         transaction.totalShippingCost = t_transaction.totalShippingCost
     if t_transaction.totalCodCharges:
         transaction.totalCodCharges = t_transaction.totalCodCharges
     totalAmount = 0
+    wallet_amount = 0.0
     for t_order in t_orders:
         order = create_order(t_order)
         totalAmount = totalAmount + order.total_amount
+        wallet_amount = wallet_amount + order.wallet_amount
         order.transaction = transaction
         for line_item in t_order.lineitems:
             litem = LineItem()
             litem.item_id = line_item.item_id
             litem.productGroup = line_item.productGroup
             session.commit()
     # EMI charges can not be charged by merchant as per RBI guidelines.
     #Now we do not have any other charges, So commenting it out.
     #generateOtherCharges(transaction, t_transaction.emiSchemeId, totalAmount)
+    """Update amount in wallet"""
     return transaction.id
 def generateOtherCharges(transaction, emiSchemeId, totalAmount):
     emiScheme = EmiScheme.get_by(id=emiSchemeId)
     if not emiScheme:
     transaction.status = new_status
     transaction.status_message = description
     expectedDelayMap = {}
     billingWarehouseIdMap = {}
     billingWarehouseTxnMap = {}
+    if new_status in (TransactionStatus.AUTHORIZED, TransactionStatus.FLAGGED, TransactionStatus.COD_IN_PROCESS):
+        wallet_amount_used = 0.0
+        for order in transaction.orders:
+            wallet_amount_used = wallet_amount_used + order.wallet_amount
+        if wallet_amount_used > 0:
+            user_wallet = get_user_wallet(transaction.orders[0].customer_id)
+            if user_wallet and user_wallet.amount < wallet_amount_used:
+                return False
+            payment_client = PaymentClient().get_client()
+            payments = payment_client.getPaymentForTxnId(order.transaction_id)
+            wallet_payment_exist = False
+            for payment in payments:
+                if payment.gatewayId == walletGatewayId:
+                    wallet_payment_exist = True
+                    payment_client.updatePaymentDetails(payment.paymentId, "", "", "SUCCESS", "Payment Received", "", "", "", "", PaymentStatus.SUCCESS, "", None);
+            if not wallet_payment_exist:
+                return False
+            consume_wallet(transaction.orders[0].customer_id, wallet_amount_used, transaction_id, WalletReferenceType.PURCHASE)
     ## Assign runner in case of delhi pincodes
     if transaction.orders[0].pickupStoreId:
         logistics_client = LogisticsClient().get_client()
         store = logistics_client.getPickupStore(transaction.orders[0].pickupStoreId)
         if delhi_pincodes.__contains__(store.pin):
 def __capture_txn(order):
     txnId = order.transaction_id
     logging.info("Capturing payment for merchant txn:" + str(txnId))
     try:
         payment_client = PaymentClient().get_client()
-        payment = payment_client.getPaymentForTxnId(order.transaction_id)
+        payments = payment_client.getPaymentForTxnId(order.transaction_id)
-        if payment[0].gatewayId == 9:
+        for payment in payments:
+            if payment.gatewayId in (gvGatewayId, walletGatewayId):
-            return
+                continue
-        capture_result = payment_client.capturePayment(txnId, False)
+            capture_result = payment_client.capturePayment(txnId, False)
-        if capture_result:
+            if capture_result:
-            logging.info("Successfully captured payment for merchant txn:" + str(txnId))
+                logging.info("Successfully captured payment for merchant txn:" + str(txnId))
-            change_transaction_status(txnId, TransactionStatus.IN_PROCESS, "Payment received", PickUpType.COURIER, order.orderType, order.source)
+                change_transaction_status(txnId, TransactionStatus.IN_PROCESS, "Payment received", PickUpType.COURIER, order.orderType, order.source)
-        else:
+            else:
-            raise TransactionServiceException(115, "Payment capture failed.")
+                raise TransactionServiceException(115, "Payment capture failed.")
     except PaymentException as e:
         if e.error_code == 106:
             order.status = OrderStatus.CAPTURE_IN_PROCESS
             session.commit()
             raise TransactionServiceException(122, "Unable to capture payment due to connection issue.")
         if recharge_order.status == RechargeOrderStatus.RECHARGE_FAILED:
             return True
         recharge_order.status = RechargeOrderStatus.RECHARGE_FAILED
         recharge_order.responseTimestamp = datetime.datetime.now()
         session.commit()
-        update_amount_in_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, 1)
+        #update_amount_in_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, 1)
+        reverse_money_to_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, WalletReferenceType.RECHARGE)
-        update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+        #update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+        add_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, WalletReferenceType.RECHARGE, False, True)
         enqueue_recharge_info_email(recharge_order)
         return True
     if rechargeOrderStatus == RechargeOrderStatus.RECHARGE_SUCCESSFUL:
         if recharge_order.status == RechargeOrderStatus.RECHARGE_SUCCESSFUL:
         if recharge_order.status == RechargeOrderStatus.RECHARGE_FAILED_REFUNDED:
             return True
         recharge_order.status = RechargeOrderStatus.RECHARGE_FAILED_REFUNDED
         recharge_order.responseTimestamp = datetime.datetime.now()
         session.commit()
-        update_amount_in_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, 1)
+        #update_amount_in_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, 1)
-        update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+        #update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+        reverse_money_to_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, WalletReferenceType.RECHARGE)
+        add_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, WalletReferenceType.RECHARGE, False, True)
         enqueue_recharge_info_email(recharge_order)
         return True
     if rechargeOrderStatus == RechargeOrderStatus.PAYMENT_SUCCESSFUL:
         gvs = {}
         recharge_order.status = RechargeOrderStatus.PAYMENT_SUCCESSFUL
         session.commit()
         if recharge_order.walletAmount > 0:
             wallet = get_user_wallet(recharge_order.userId)
             if wallet and wallet.amount >= recharge_order.walletAmount:
-                update_amount_in_wallet(recharge_order.userId, -recharge_order.walletAmount, recharge_order.id, 1)
+                #update_amount_in_wallet(recharge_order.userId, -recharge_order.walletAmount, recharge_order.id, 1)
+                consume_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, WalletReferenceType.RECHARGE)
             else:
                 ## User is trying to play smart. Let us first mark his recharge failed and then credit payment amount to his wallet.
                 recharge_order.status = RechargeOrderStatus.RECHARGE_FAILED
                 recharge_order.responseTimestamp = datetime.datetime.now()
                 session.commit()
-                update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+                #update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+                consume_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, WalletReferenceType.RECHARGE)
                 raise TransactionServiceException(103, 'Wallet amount has already been used')
         try:
             if activate_recharge_txn(recharge_order):
                 recharge_order.invoiceNumber = get_next_invoice_number(OrderType.RECHARGE)
                 session.commit()
                 gvs = allocate_gift_voucher(recharge_order)
                 return True
             else:
-                update_amount_in_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, 1)
+                #update_amount_in_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, 1)
-                update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+                #update_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, 0)
+                reverse_money_to_wallet(recharge_order.userId, recharge_order.walletAmount, recharge_order.id, WalletReferenceType.RECHARGE)
+                add_amount_in_wallet(recharge_order.userId, recharge_order.totalAmount - recharge_order.walletAmount - recharge_order.couponAmount, recharge_order.id, WalletReferenceType.RECHARGE, False, True)
                 session.commit()
                 return False
         except:
             if isinstance(recharge_order, MobileRechargeOrder):
                 if recharge_order.mobileOperatorId not in (getSyncOperatorsForRecharge()):
     wallet = UserWallet.get_by(userId = userId)
     if not wallet:
         wallet = UserWallet()
         wallet.amount = 0
         wallet.userId = userId
+        wallet.refundable_amount = 0
     return wallet
 def get_user_wallet_history(userId):
     wallet = get_user_wallet(userId)
     if wallet.id:
     return "SUCCESS"
 def get_previous_transactions(clientAddress):
     limittime = datetime.datetime.now() - datetime.timedelta(hours=24)
     totalSuccessfulRechargeAmount = session.query(func.sum(RechargeOrder.totalAmount)).filter(RechargeOrder.status == 5).filter(RechargeOrder.ipAddress == clientAddress).filter(RechargeOrder.creationTimestamp  > limittime).scalar()
     return totalSuccessfulRechargeAmount
-def update_amount_in_wallet(userId, amount, orderId, updateType):
+def add_amount_in_wallet(userId, amount, reference, reference_type, isPromotional, commit_session=False):
     """
-    UpdateType 1 is for wallet amounts
-    and 0 is for payment amounts
+    Commit to be executed by caller
     """
+    if not amount > 0 or WalletReferenceType._VALUES_TO_NAMES.get(reference_type) is None:
+        return
+    wallet = get_user_wallet(userId)
+    wallet.amount = wallet.amount + amount
+    history = UserWalletHistory()
+    if not isPromotional:
+        wallet.refundable_amount = wallet.refundable_amount + amount
-    if amount == 0:
+    history.amount = amount
+    history.refundable_amount = amount
+    history.reference = reference
+    history.reference_type = WalletReferenceType._VALUES_TO_NAMES.get(reference_type)
+    history.wallet = wallet
+    history.timestamp = datetime.datetime.now()
+    if commit_session:
+        session.commit()
+def consume_wallet(userId, amount, reference, reference_type):
+    if amount <= 0 or WalletReferenceType._VALUES_TO_NAMES.get(reference_type) is None:
+        return
+    wallet = get_user_wallet(userId)
+    if wallet.amount < amount:
+        return
+    refundable_amount = wallet.refundable_amount
+    promotional_amount = wallet.amount - wallet.refundable_amount
+    refundable_amount_used = 0
+    if promotional_amount < amount:
+        refundable_amount = refundable_amount - (amount - promotional_amount)
+        promotional_amount = 0
+        refundable_amount_used = amount - promotional_amount
+    else:
+        promotional_amount = promotional_amount - amount
+    wallet.amount = promotional_amount + refundable_amount
+    wallet.refundable_amount = refundable_amount
+    history = UserWalletHistory()
+    history.amount = -amount
+    history.refundable_amount = -refundable_amount_used
+    history.reference = reference
+    history.reference_type = WalletReferenceType._VALUES_TO_NAMES.get(reference_type)
+    history.wallet = wallet
+    history.timestamp = datetime.datetime.now()
+    session.commit()
+def refund_amount_from_wallet(userId, amount, reference, reference_type):
+    if amount <= 0 or WalletReferenceType._VALUES_TO_NAMES.get(reference_type) is None:
+        return
+    wallet = get_user_wallet(userId)
+    if wallet.refundable_amount < amount or wallet.amount < amount:
+        return
+    wallet.amount = wallet.amount - amount
+    wallet.refundable_amount = wallet.refundable_amount - amount
+    history = UserWalletHistory()
+    history.amount = -amount
+    history.refundable_amount = -amount
+    history.reference = reference
+    history.reference_type = WalletReferenceType._VALUES_TO_NAMES.get(reference_type)
+    history.wallet = wallet
+    history.timestamp = datetime.datetime.now()
+    session.commit()
+def reverse_money_to_wallet(userId, amount, reference, reference_type):
+    """To only reverse wallet payments, check add_amount_in_wallet to add new amount"""
+    if amount <= 0 or WalletReferenceType._VALUES_TO_NAMES.get(reference_type) is None:
         return
     history = None
-    if updateType == 1 and amount > 0 :
+    if reference_type==WalletReferenceType.RECHARGE:
-        history = UserWalletHistory.query.filter_by(orderId = orderId).filter_by(amount = -amount).order_by(UserWalletHistory.id.desc()).first()
+        history = UserWalletHistory.query.filter_by(reference = reference).filter_by(reference_type = WalletReferenceType._VALUES_TO_NAMES.get(reference_type)).filter_by(amount = -amount).order_by(UserWalletHistory.id.desc()).first()
         if history is None:
-            print 'No amount was debited from wallet for recharge Id : ' + str(orderId)
+            print 'No amount was debited from wallet for recharge Id : ' + str(reference)
             return
-    """
-    TODO check if successful payment available or Not
+    elif reference_type==WalletReferenceType.PURCHASE:
-    elif updateType == 0 :
-        baseorder = BaseOrder.query.filter_by(id = orderId).first()
+        history = UserWalletHistory.query.filter_by(reference = reference).filter_by(reference_type = WalletReferenceType._VALUES_TO_NAMES.get(reference_type)).filter_by(amount = -amount).order_by(UserWalletHistory.id.desc()).first()
-        if baseorder :
+        if history is None:
-            try :
-                pc = PaymentClient().get_client()
-                payments = pc.getPaymentForRechargeTxnId(baseorder.transaction.id)
+            print 'No amount was debited from wallet for purchase : ' + str(reference)
-            except Exception as e:
-                print e
-                return
-            for payment in payments :
-                if payment.status == 2 :
-                    break
-        else :
             return
+    else:
+        print "Reference is not valid"
-      """
+        return
     wallet = get_user_wallet(userId)
     wallet.amount = wallet.amount + amount
+    wallet.refundable_amount = wallet.refundable_amount -history.refundable_amount
     history = UserWalletHistory()
     history.amount = amount
+    history.refundable_amount = -history.refundable_amount
-    history.orderId = orderId
+    history.reference = reference
+    history.reference_type = WalletReferenceType._VALUES_TO_NAMES.get(reference_type)
     history.wallet = wallet
     history.timestamp = datetime.datetime.now()
     session.commit()
+#def update_amount_in_wallet(userId, amount, orderId, updateType):
+#    return
+#    """
+#    UpdateType 1 is for wallet amounts
+#    and 0 is for payment amounts
+#    """
+#    if amount == 0:
+#        return
+#
+#    history = None
+#    if updateType == 1 and amount > 0 :
+#        history = UserWalletHistory.query.filter_by(orderId = orderId).filter_by(amount = -amount).order_by(UserWalletHistory.id.desc()).first()
+#        if history is None:
+#            print 'No amount was debited from wallet for recharge Id : ' + str(orderId)
+#            return
+#
+#    """
+#    TODO check if successful payment available or Not
+#    elif updateType == 0 :
+#        baseorder = BaseOrder.query.filter_by(id = orderId).first()
+#        if baseorder :
+#            try :
+#                pc = PaymentClient().get_client()
+#                payments = pc.getPaymentForRechargeTxnId(baseorder.transaction.id)
+#            except Exception as e:
+#                print e
+#                return
+#            for payment in payments :
+#                if payment.status == 2 :
+#                    break
+#        else :
+#            return
+#      """
+#    wallet = get_user_wallet(userId)
+#    wallet.amount = wallet.amount + amount
+#
+#    history = UserWalletHistory()
+#    history.amount = amount
+#    history.orderId = orderId
+#    history.wallet = wallet
+#    history.timestamp = datetime.datetime.now()
+#    session.commit()
 def get_recharge_orders_for_device(deviceNumber):
     orders = MobileRechargeOrder.query.filter_by(mobileNumber = deviceNumber).all()
     if orders is None:
         orders = DTHRechargeOrder.query.filter_by(dthAccountNumber = deviceNumber).all()
         return False
     paidAmount = rechargeOrder.totalAmount - rechargeOrder.walletAmount - rechargeOrder.couponAmount
     amountToRefund = 0
     status = None
-    if (paidAmount <= wallet.amount) :
+    if (paidAmount <= wallet.refundable_amount) :
         amountToRefund = paidAmount
         status = RechargeOrderStatus.REFUNDED
     else :
-        amountToRefund = wallet.amount
+        amountToRefund = wallet.refundable_amount
         status = RechargeOrderStatus.PARTIALLY_REFUNDED
-    update_amount_in_wallet(rechargeOrder.userId, -amountToRefund, rechargeOrderId, 1)
+    #update_amount_in_wallet(rechargeOrder.userId, -amountToRefund, rechargeOrderId, 1)
+    refund_amount_from_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, WalletReferenceType.RECHARGE)
     try:
         pc = PaymentClient().get_client()
         if pc.refundPayment(rechargeOrder.transaction_id, amountToRefund, True) :
             rechargeOrder.status = status
             rechargeOrder.refundTimestamp = datetime.datetime.now()
             session.commit()
             return True
         else :
-            update_amount_in_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, 1)
+            #update_amount_in_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, 1)
+            add_amount_in_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, WalletReferenceType.RECHARGE, False, True)
     except:
-        update_amount_in_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, 1)
+        #update_amount_in_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, 1)
+        add_amount_in_wallet(rechargeOrder.userId, amountToRefund, rechargeOrderId, WalletReferenceType.RECHARGE, False, True)
     return False
 def get_physical_orders(from_date, to_date):
     query = Order.query.filter(Order.created_timestamp >from_date).filter(Order.created_timestamp < to_date).filter(~Order.status.in_([0,1,6,11,14,15,18,19,31,34,28,53,54,55,56,20,21,77,79,78]))
     if gv_amount > 0:
         paymentId = payment_client.createPayment(userId, gv_amount, gvGatewayId, txnId, False);
         payment_client.updatePaymentDetails(paymentId, "", "", "SUCCESS", "Payment Received", "", "", "", "", PaymentStatus.SUCCESS, "", None);
     if wallet_amount > 0:
         paymentId = payment_client.createPayment(userId, wallet_amount, walletGatewayId, txnId, False);
-        payment_client.updatePaymentDetails(paymentId, "", "", "SUCCESS", "Payment Received", "", "", "", "", PaymentStatus.SUCCESS, "", None);
     if total_payable_amount > 0:
         paymentId = payment_client.createPayment(userId, total_payable_amount, gatewayId, txnId, False);
     return paymentId

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/model/v1/order/impl/DataAccessors.py – Rev 20876 → 20927