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

     RechargeTransaction, HotspotStore, WalletForCompany, WalletHistoryForCompany, \
     FRC, OperatorSeries, SourceDetail, Company, EbayOrder, AmazonFbaSalesSnapshot, \
     AmazonOrder, StoreOrderDetail, EdcBank, StoreOrderCollection, \
     HotspotServiceMatrix, SnapdealOrder, FlipkartOrder, DataInsuranceDetailForOrder, \
     AmazonFbaOrderReturns, FlipkartAdvantageOrder, InvoiceCounterGenerator, \
-    TransactionShipmentSequence, HsOrder
+    TransactionShipmentSequence, HsOrder, Creditor, UserSanction, CreditHistory, LoanHistory
 from shop2020.model.v1.order.impl.model.BaseOrder import BaseOrder
 from shop2020.model.v1.order.impl.model.DTHRechargeOrder import DTHRechargeOrder
 from shop2020.model.v1.order.impl.model.MobileRechargeOrder import \
     MobileRechargeOrder
 from shop2020.model.v1.order.impl.model.RechargeDenomination import \
 from shop2020.thriftpy.model.v1.order.ttypes import TransactionServiceException, \
     TransactionStatus, OrderStatus, DelayReason, ExtraTransactionProcessingType, \
     HotspotAction, TimeoutSummary, OrderStatusGroups, OrderType, RechargeOrderStatus, \
     RechargeType, RechargeStatistics, DeviceNumberInfo, EmiChargeType, PayMethod, \
     OrderSource, StorePaymentStatus, ProductCondition, TaxType, \
-    AmazonFCWarehouseLocation, RechargeMode
+    AmazonFCWarehouseLocation, RechargeMode, CreditTxnType, CreditHistory as TCreditHistory, \
+    LoanHistory as TLoanHistory
 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, \
         OrderStatus.RTO_IN_TRANSIT   : -5,
         OrderStatus.DELIVERY_SUCCESS :  1,
         OrderStatus.DOA_CERT_INVALID : -5
+}
+creditTxnMultiplierMap = {
+    CreditTxnType.BLOCKED : 1,
+    CreditTxnType.BLOCK_REVERSED : -1,
+    CreditTxnType.LOAN : -1,
+    CreditTxnType.CORRECTION : 1
+}
+loanTxnMultplierMap = {
+    CreditTxnType.LOAN : 1,
+    CreditTxnType.LOAN_CANCELLED : -1,
+    CreditTxnType.PAID : -1,
+    CreditTxnType.CORRECTION : -1
+}
 stateIdMap = {}
 def fetchStateMaster():
     global stateIdMap
     if stateIdMap:
     if new_status == TransactionStatus.FAILED:
         for order in transaction.orders:
             order.status = OrderStatus.PAYMENT_FAILED
             order.statusDescription = "Payment Failed"
     elif new_status == TransactionStatus.AUTHORIZED or new_status == TransactionStatus.FLAGGED:
         if transaction.payment_option == capitalFloatPayMethod:
-            pass
+            total_amount = 0
+            singleOrder = transaction.orders[0]
+            for order in transaction.orders:
+                total_amount = total_amount + order.total_amount + order.shippingCost - order.gvAmount
+            creditObj = __creditHistoryObj(singleOrder.customer_id, 1, transaction.id, total_amount, CreditTxnType.BLOCKED, str(transaction.id))
+            creditTxns = []
+            creditTxns.append(creditObj)
+            process_credit_transaction(transaction.id, singleOrder.customer_id, 1, creditTxns)
         for order in transaction.orders:
             if new_status == TransactionStatus.AUTHORIZED:
                 order.status = OrderStatus.SUBMITTED_FOR_PROCESSING
                 order.statusDescription = "Submitted to warehouse"
             elif new_status == TransactionStatus.FLAGGED:
                     print "Exception in scheduling alert in ShippedFromWarehouse method"
                     print e
     for logisticsTxnId, ordersList in logisticsTxnIdOrdersMap.iteritems():
         if enqueue_delivery_success_mail(logisticsTxnId, ordersList) :
+            order = orderList[0]
+            if order.transaction.payment_option == capitalFloatPayMethod:
+                total_amount = 0
+                for ordObj in orderList:
+                    total_amount = total_amount + ordObj.total_amount + ordObj.shippingCost - ordObj.gvAmount
+                creditObj = __creditHistoryObj(order.customer_id, 1, order.transaction.id, total_amount, CreditTxnType.LOAN, order.logisticsTransactionId)
+                creditTxns = []
+                creditTxns.append(creditObj)
+                try:
+                    process_credit_transaction(order.transaction.id, order.customer_id, 1, creditTxns)
+                except:
+                    traceback.print_exc()
+                    session.rollback()
+                    return
             session.commit()
         else :
             session.rollback()
                 logisticsTxnIdOrdersMap[order.logisticsTransactionId]= orderList
     else:
         grouppedOrdersList.append(singleOrder)
         logisticsTxnIdOrdersMap[str(singleOrder.id)]= grouppedOrdersList
+    for logisticsTxnId, ordersList in logisticsTxnIdOrdersMap.iteritems():
+        order = orderList[0]
+        if order.transaction.payment_option == capitalFloatPayMethod:
+            total_amount = 0
+            for ordObj in orderList:
+                total_amount = total_amount + ordObj.total_amount + ordObj.shippingCost - ordObj.gvAmount
+            creditObj = __creditHistoryObj(order.customer_id, 1, order.transaction.id, total_amount, CreditTxnType.LOAN, order.logisticsTransactionId)
+            creditTxns = []
+            creditTxns.append(creditObj)
+            try:
+                process_credit_transaction(order.transaction.id, order.customer_id, 1, creditTxns)
+            except:
+                traceback.print_exc()
+                session.rollback()
+                return
     for order in grouppedOrdersList:
         if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY, OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.DOA_PICKUP_REQUEST_RAISED, OrderStatus.DOA_PICKUP_CONFIRMED, OrderStatus.RET_REQUEST_RECEIVED, OrderStatus.RET_PICKUP_CONFIRMED, OrderStatus.RET_REQUEST_AUTHORIZED, OrderStatus.RET_PICKUP_REQUEST_RAISED, OrderStatus.RTO_IN_TRANSIT, OrderStatus.BILLED, OrderStatus.RECEIVED_AT_STORE]:
             raise TransactionServiceException(101, "Either wrong order id or invalid state " + str(orderId))
         # Provider is 4 is for self pickup and hardcoded. We should figure out a way to not to hard code.
             OrderStatus.DOA_RECEIVED_PRESTINE : ScanType.DOA_IN,
             OrderStatus.DOA_RECEIVED_DAMAGED  : ScanType.DOA_IN,
             OrderStatus.DOA_LOST_IN_TRANSIT   : ScanType.LOST_IN_TRANSIT
+        }
         if orderCurrentStatus == OrderStatus.RTO_IN_TRANSIT:
+            order = grouppedOrdersList[0]
+            if order.transaction.payment_option == capitalFloatPayMethod:
+                total_amount = 0
+                for ordObj in grouppedOrdersList:
+                    total_amount = total_amount + ordObj.total_amount + ordObj.shippingCost - ordObj.gvAmount
+                if not order.delivery_timestamp:
+                    creditObj = __creditHistoryObj(order.customer_id, 1, order.transaction.id, total_amount, CreditTxnType.BLOCK_REVERSED, order.logisticsTransactionId)
+                    creditTxns = []
+                    creditTxns.append(creditObj)
+                    try:
+                        process_credit_transaction(order.transaction.id, order.customer_id, 1, creditTxns)
+                    except:
+                        traceback.print_exc()
+                        session.rollback()
+                        return False
+                else:
+                    loanObj = __loanHistoryObj(order.customer_id, 1, order.transaction.id, total_amount, CreditTxnType.CORRECTION, order.logisticsTransactionId)
+                    loanTxns = []
+                    loanTxns.append(loanObj)
+                    try:
+                        process_loan_transaction(order.transaction.id, order.customer_id, 1, loanTxns)
+                    except:
+                        traceback.print_exc()
+                        session.rollback()
+                        return False
             for orderObj in grouppedOrdersList:
                 if scanMap.has_key(orderObj.status):
                     scanType = scanMap[orderObj.status]
                     lineitem = orderObj.lineitems[0]
                     catalogClient = CatalogClient().get_client()
             elif order.previousStatus == OrderStatus.BILLED:
                 __create_return_order(order)
                 __create_refund(order)
                 order.statusDescription = "Order Cancelled on customer request"
                 order.received_return_timestamp = datetime.datetime.now()
+            if order.transaction.payment_option == capitalFloatPayMethod:
+                total_amount = order.total_amount + order.shippingCost - order.gvAmount
+                creditObj = __creditHistoryObj(order.customer_id, 1, order.transaction.id, total_amount, CreditTxnType.BLOCK_REVERSED, order.logisticsTransactionId)
+                creditTxns = []
+                creditTxns.append(creditObj)
+                try:
+                    process_credit_transaction(order.transaction.id, order.customer_id, 1, creditTxns)
+                except:
+                    traceback.print_exc()
+                    session.rollback()
+                    return False
         elif order.status == OrderStatus.PAYMENT_FLAGGED:
             __update_inventory_reservation(order)
             order.statusDescription = "Order Cancelled due to payment flagged"
     # For orders that are cancelled after being billed, we need to scan in the scanned out
     for ordObj in grouppedOrders:
         if ordObj.id not in orderIds:
             errorString = errorString + "Order Id:- " +str(ordObj.id) +" "
-    errorString = errorString.strip()
     if len(errorString)>0:
         raise TransactionServiceException(301, missingString + errorString)
     #inventoryDbConnection = getDbConnection("192.168.190.114","root", "shop2020", "inventory")
     try:
         warehouseDbConnection = getDbConnection("localhost","root", "shop2020", "warehouse")
     except:
         raise TransactionServiceException(302, "Unable to connect to Warehouse System")
             try:
                 if not inventory_client.isAlive():
                     inventory_client = InventoryClient().get_client()
                 warehouse = inventory_client.getWarehouse(order.fulfilmentWarehouseId)
-                if order.productCondition == ProductCondition.GOOD:
+                if order.productCondition == ProductCondition.BAD:
                     item_pricing = inventory_client.getItemPricing(item_id, warehouse.vendor.id)
                     lineitem.transfer_price = item_pricing.transferPrice
                     lineitem.nlc = item_pricing.nlc
                 if order.taxType == TaxType.CFORM:
                     lineitem.vatRate = 2
                         warehouse = inventory_client.getWarehouses(None, InventoryType.GOOD, warehouse.vendor.id, order.warehouse_id, 0)[0]
                     whCursor = warehouseDbConnection.cursor()
                     ''' Good Serialized'''
                     if ItemType.SERIALIZED == item.type:
                         for serialNumber in serialNumbers:
                             serialNumber = serialNumber.strip()
                             if len(serialNumber) ==0:
                                 raise TransactionServiceException(315, "Serial Number not Specified. Order Id:- "+str(order.id))
                             invItemSql = "select i.id, i.itemId, i.itemNumber, i.serialNumber, i.initialQuantity, i.currentQuantity, i.purchaseId, i.purchaseReturnId, i.currentWarehouseId, i.lastScanType, i.transferStatus, physicalWarehouseId, po.supplierId, l.unitPrice, l.nlc from inventoryItem i join purchase p on i.purchaseId = p.id join purchaseorder po on p.purchaseOrder_id = po.id join lineitem l on (i.itemId = l.itemId and po.id =l.purchaseOrder_id) where i.serialNumber ='%s' order by i.id desc limit 1"%(serialNumber)
                             whCursor.execute(invItemSql)
                             invItem = whCursor.fetchone()
                             if invItem is None:
                                 if warehouseDbConnection.open:
                     whCursor = warehouseDbConnection.cursor()
                     if ItemType.SERIALIZED == item.type:
                         for serialNumber in serialNumbers:
                             serialNumber = serialNumber.strip()
                             if len(serialNumber) ==0:
                                 raise TransactionServiceException(315, "Serial Number not Specified. Order Id:- "+str(order.id))
                             invItemSql = "select i.id, i.itemId, i.itemNumber, i.serialNumber, i.initialQuantity, i.currentQuantity, i.purchaseId, i.purchaseReturnId, i.currentWarehouseId, i.lastScanType, i.transferStatus, physicalWarehouseId, po.supplierId, l.unitPrice, l.nlc from inventoryItem i join purchase p on i.purchaseId = p.id join purchaseorder po on p.purchaseOrder_id = po.id join lineitem l on (i.itemId = l.itemId and po.id =l.purchaseOrder_id) where i.serialNumber ='%s' order by i.id desc limit 1"%(serialNumber)
                             whCursor.execute(invItemSql)
                             invItem = whCursor.fetchone()
                             if invItem is None:
                                 if warehouseDbConnection.open:
 def verify_orders_for_transaction(transactionId):
     transaction = get_transaction(transactionId)
     for order in transaction.orders:
         __verify_order(order)
     return True
+def get_creditor_info(creditorId):
+    return Creditor.get_by(id=creditorId)
+def update_creditor_info(creditor):
+    t_creditor = get_creditor_info(creditor.id)
+    t_creditor.active = creditor.active
+    if t_creditor.name != creditor.name:
+        t_creditor.name = creditor.name
+    session.commit()
+    return True
+def get_user_sanction_details(userId, creditorId):
+    us_query = UserSanction.query
+    if userId:
+        us_query = us_query.filter(UserSanction.user_id == userId)
+    if creditorId:
+        us_query = us_query.filter(UserSanction.creditor_id == creditorId)
+    return us_query.all()
+def update_user_sanction(userSanction):
+    userS = UserSanction.get_by(id=userSanction.id)
+    if userS is None:
+        return False
+    else:
+        userS.credit_blocked = userSanction.credit_blocked
+        userS.loan = userSanction.loan
+        userS.active = userSanction.active
+        session.commit()
+        return True
+def __get_user_sanction(sanctionId):
+    return UserSanction.get_by(id=sanctionId)
+def get_credit_history_records(paymentId, userId, creditorId, creditTxnType):
+    credit_hs_query = CreditHistory.query
+    if paymentId:
+        credit_hs_query = credit_hs_query.filter(CreditHistory.payment_id==paymentId)
+    if userId:
+        credit_hs_query = credit_hs_query.filter(CreditHistory.user_id==userId)
+    if creditorId:
+        credit_hs_query = credit_hs_query.filter(CreditHistory.creditor_id==creditorId)
+    if creditTxnType:
+        credit_hs_query = credit_hs_query.filter(CreditHistory.credit_type==CreditTxnType._VALUES_TO_NAMES[creditTxnType])
+    return credit_hs_query.all()
+def process_credit_transaction(paymentId, userId, creditorId, creditTxns):
+    userSanctions = get_user_sanction_details(userId, creditorId)
+    if userSanctions is None or len(userSanctions)==0:
+        logging.info("No Credit Sanction Details Availble. UserId:- "+str(userId)+ " Creditor Id:- "+ str(creditorId))
+        raise TransactionServiceException(221, "No Credit Sanction Details Availble. UserId:- "+str(userId)+ " Creditor Id:- "+ str(creditorId))
+    userSanction = userSanctions[0]
+    availableCredit =  userSanction.credit_limit - (userSanction.credit_blocked + userSanction.loan)
+    amountToReversed = 0
+    amountToLoan = 0
+    amountToBlocked = 0
+    creditHistoryTotal = 0
+    allCreditTxns = get_credit_history_records(paymentId, userId, creditorId, None)
+    for credit_txn in allCreditTxns:
+        creditHistoryTotal = creditHistoryTotal + credit_txn.amount
+    if creditHistoryTotal < 0:
+        logging.info("Error: Credit History is Negative. Payment Id:- "+str(paymentId))
+        raise TransactionServiceException(222, "Error: Credit History is Negative. Payment Id:- "+str(paymentId))
+    for creditTxn in creditTxns:
+        if creditTxn.credit_type in [CreditTxnType.BLOCK_REVERSED]:
+            amountToReversed = amountToReversed + creditTxn.amount
+        if creditTxn.credit_type in [CreditTxnType.LOAN]:
+            amountToLoan = amountToLoan + creditTxn.amount
+        if creditTxn.credit_type in [CreditTxnType.BLOCKED]:
+            amountToBlocked = amountToBlocked + creditTxn.amount
+    if amountToLoan > userSanction.credit_blocked:
+        logging.info("Error: Not Enough Credit to Process For Loan. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(creditTxns[0].shipping_id))
+        raise TransactionServiceException(224, "Error: Not Enough Credit to Process For Loan. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(creditTxns[0].shipping_id))
+    if amountToReversed > userSanction.credit_blocked:
+        logging.info("Error: Not Enough Credit to Process For Reversal. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(creditTxns[0].shipping_id))
+        raise TransactionServiceException(225, "Error: Not Enough Credit to Process For Reversal. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(creditTxns[0].shipping_id))
+    if amountToBlocked > availableCredit:
+        logging.info("Error: Not Enough Credit to be Blocked. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(creditTxns[0].shipping_id))
+        raise TransactionServiceException(226, "Error: Not Enough Credit to be Blocked. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(creditTxns[0].shipping_id))
+    for creditTxn in creditTxns:
+        creditHistoryRec = CreditHistory.get_by(payment_id=paymentId,shipping_id=creditTxn.shipping_id)
+        if creditHistoryRec is None:
+            creditHistoryRec = CreditHistory()
+            creditHistoryRec.user_id = userId
+            creditHistoryRec.creditor_id = creditorId
+            creditHistoryRec.payment_id = paymentId
+            creditHistoryRec.amount = creditTxn.amount * creditTxnMultiplierMap.get(creditTxn.credit_type)
+            creditHistoryRec.credit_type = CreditTxnType._VALUES_TO_NAMES[creditTxn.credit_type]
+            creditHistoryRec.shipping_id = creditTxn.shipping_id
+            userSanction.credit_blocked = userSanction.credit_blocked + (creditTxn.amount * creditTxnMultiplierMap.get(creditTxn.credit_type))
+            if creditTxn.credit_type in [CreditTxnType.LOAN]:
+                userSanction.loan = userSanction.loan + creditTxn.amount
+                loanHistoryRec = LoanHistory()
+                loanHistoryRec.user_id = userId
+                loanHistoryRec.creditor_id = creditorId
+                loanHistoryRec.payment_id = paymentId
+                loanHistoryRec.amount = creditTxn.amount * loanTxnMultplierMap.get(creditTxn.credit_type)
+                loanHistoryRec.credit_type = CreditTxnType._VALUES_TO_NAMES[creditTxn.credit_type]
+                loanHistoryRec.loan_id = creditTxn.loan_id
+                loanHistoryRec.due_date = datetime.datetime.now()+timedelta(days=30)
+        else:
+            logging.info("Error: Entry already existed for "+str(paymentId) + " Shipping Id:- "+str(creditTxns.shipping_id) +" Credit Txn Type:- "+CreditTxnType._VALUES_TO_NAMES[creditTxn.credit_type]+ " in Credit History ")
+            raise TransactionServiceException(227, "Error: Entry already existed for "+str(paymentId) + " Shipping Id:- "+str(creditTxns.shipping_id) +" Credit Txn Type:- "+CreditTxnType._VALUES_TO_NAMES[creditTxn.credit_type]+ " in Credit History ")
+    session.commit()
+    return True
+def get_loan_payable_for_user_to_creditor(userId, creditorId, dueDate):
+    loanhistoryRecords = LoanHistory.query.filter(and_(LoanHistory.user_id==userId, LoanHistory.creditor_id==creditorId, LoanHistory.due_date<to_py_date(dueDate), LoanHistory.updated is None)).all()
+    loanAmount = 0
+    for loanHistory in loanhistoryRecords:
+        loanAmount = loanAmount + loanHistory.amount
+    return loanAmount
+def get_loan_history_records(paymentId, userId, creditorId, creditTxnType):
+    loan_hs_query = LoanHistory.query
+    if paymentId:
+        loan_hs_query = loan_hs_query.filter(LoanHistory.payment_id==paymentId)
+    if userId:
+        loan_hs_query = loan_hs_query.filter(LoanHistory.user_id==userId)
+    if creditorId:
+        loan_hs_query = loan_hs_query.filter(LoanHistory.creditor_id==creditorId)
+    if creditTxnType:
+        loan_hs_query = loan_hs_query.filter(LoanHistory.credit_type==CreditTxnType._VALUES_TO_NAMES[creditTxnType])
+    return loan_hs_query.all()
+def process_loan_transaction(paymentId, userId, creditorId, loantxns):
+    userSanctions = get_user_sanction_details(userId, creditorId)
+    if userSanctions is None or len(userSanctions)==0:
+        logging.info("No Credit Sanction Details Availble. UserId:- "+str(userId)+ " Creditor Id:- "+ str(creditorId))
+        raise TransactionServiceException(227, "No Credit Sanction Details Availble. UserId:- "+str(userId)+ " Creditor Id:- "+ str(creditorId))
+    userSanction = userSanctions[0]
+    amountToLoan = 0
+    amountToLoanPaid = 0
+    amountToCorrected = 0
+    loanHistoryTotal = 0
+    allLoanTxns = get_loan_history_records(paymentId, userId, creditorId, None)
+    for loan_txn in allLoanTxns:
+        loanHistoryTotal = loanHistoryTotal + loan_txn.amount
+    if loanHistoryTotal < 0:
+        logging.info("Error: Loan History is Negative. Payment Id:- "+str(paymentId))
+        raise TransactionServiceException(228, "Error: Loan History is Negative. Payment Id:- "+str(paymentId))
+    for loanTxn in loantxns:
+        if loanTxn.credit_type in [CreditTxnType.LOAN]:
+            amountToLoan = amountToLoan + loanTxn.amount
+        if loanTxn.credit_type in [CreditTxnType.PAID]:
+            amountToLoanPaid = amountToLoanPaid + loanTxn.amount
+        if loanTxn.credit_type in [CreditTxnType.CORRECTION]:
+            amountToCorrected = amountToCorrected + loanTxn.amount
+    if amountToLoan > userSanction.loan:
+        logging.info("Error: Loan required is more than specified. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(loantxns[0].loan_id))
+        raise TransactionServiceException(229, "Error: Loan required is more than specified. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(loantxns[0].loan_id))
+    if amountToLoanPaid > userSanction.loan:
+        logging.info("Error: Can't Pay more than Loan Amount. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(loantxns[0].loan_id))
+        raise TransactionServiceException(230, "Error: Can't Pay more than Loan Amount. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(loantxns[0].loan_id))
+    if amountToCorrected > userSanction.loan:
+        logging.info("Error: Correction Amount More than loan Amount. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(loantxns[0].loan_id))
+        raise TransactionServiceException(231, "Error: Correction Amount More than loan Amount. Payment Id:- "+str(paymentId) + " Shipping Id:- "+str(loantxns[0].loan_id))
+    for loanTxn in loantxns:
+        if loanTxn.credit_type in [CreditTxnType.PAID]:
+            loanHistoryRecords = LoanHistory.query.filter(LoanHistory.loan_id==loanTxn.loan_id).filter(LoanHistory.payment_id==paymentId).all()
+            loanTotalHistory = 0
+            for loanHistoryRec in loanHistoryRecords:
+                loanTotalHistory = loanTotalHistory + loanHistoryRec.amount
+            if loanTotalHistory < 0:
+                logging.info("Error: Loan Already Paid or Closed for "+str(paymentId) + " Loan Id:- "+str(loanTxn.loan_id) +" Loan Txn Type:- "+CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type])
+                raise TransactionServiceException(227, "Error: Loan Already Paid or Closed for "+str(paymentId) + " Loan Id:- "+str(loanTxn.loan_id) +" Loan Txn Type:- "+CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type])
+            else:
+                loanHistoryRec = LoanHistory()
+                loanHistoryRec.user_id = userId
+                loanHistoryRec.creditor_id = creditorId
+                loanHistoryRec.payment_id = paymentId
+                loanHistoryRec.amount = loanTxn.amount * loanTxnMultplierMap.get(loanTxn.credit_type)
+                loanHistoryRec.credit_type = CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type]
+                loanHistoryRec.loan_id = loanTxn.loan_id
+                loanRec = LoanHistory.get_by(payment_id=paymentId,loan_id=loanTxn.loan_id, credit_type='LOAN')
+                userSanction.loan = userSanction.loan + (loanTxn.amount * loanTxnMultplierMap.get(loanTxn.credit_type))
+        else:
+            loanHistoryRec = LoanHistory.get_by(payment_id=paymentId,loan_id=loanTxn.loan_id, credit_type=CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type])
+            if loanHistoryRec is None:
+                loanHistoryRec = LoanHistory()
+                loanHistoryRec.user_id = userId
+                loanHistoryRec.creditor_id = creditorId
+                loanHistoryRec.payment_id = paymentId
+                loanHistoryRec.amount = loanTxn.amount * loanTxnMultplierMap.get(loanTxn.credit_type)
+                loanHistoryRec.credit_type = CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type]
+                loanHistoryRec.loan_id = loanTxn.loan_id
+                if loanTxn.credit_type in [CreditTxnType.LOAN]:
+                    loanHistoryRec.due_date = datetime.datetime.now()+timedelta(days=30)
+                if loanTxn.credit_type in [CreditTxnType.CORRECTION]:
+                    loanRec = LoanHistory.get_by(payment_id=paymentId,loan_id=loanTxn.loan_id, credit_type='LOAN')
+                    loanRec.updated = datetime.datetime.now()
+                    userSanction.loan = userSanction.loan + (loanTxn.amount * loanTxnMultplierMap.get(loanTxn.credit_type))
+            else:
+                logging.info("Error: Entry already existed for "+str(paymentId) + " Loan Id:- "+str(loanTxn.loan_id) +" Loan Txn Type:- "+CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type])
+                raise TransactionServiceException(227, "Error: Entry already existed for "+str(paymentId) + " Loan Id:- "+str(loanTxn.loan_id) +" Loan Txn Type:- "+CreditTxnType._VALUES_TO_NAMES[loanTxn.credit_type])
+    session.commit()
+    return True
+def __loanHistoryObj(user_id, creditor_id, paymentId, amount, credit_type, loan_id):
+    loanobj = TLoanHistory()
+    loanobj.user_id = user_id
+    loanobj.creditor_id = creditor_id
+    loanobj.payment_id = paymentId
+    loanobj.amount = amount
+    loanobj.credit_type = credit_type
+    loanobj.loan_id = loan_id
+    return loanobj
+def __creditHistoryObj(user_id, creditor_id, paymentId, amount, credit_type, shipping_id):
+    creditObj = TCreditHistory()
+    creditObj.user_id = user_id
+    creditObj.creditor_id = creditor_id
+    creditObj.payment_id = paymentId
+    creditObj.amount = amount
+    creditObj.credit_type = credit_type
+    creditObj.shipping_id = shipping_id
+    return creditObj
 if __name__ == '__main__':
     print get_orders_by_mobile_number("9650889334")

Subversion Repositories SmartDukaan

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