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

     returnOrder = ReturnOrderInfo.get_by(id=returnOrderId)
     if not returnOrder:
         return None
     return returnOrder
+def refund_return_order(returnOrderInfo, attrList):
+    returnOrder = ReturnOrderInfo.get_by(id=returnOrderInfo.id)
+    if returnOrder.returnStatus not in (OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_VALID], OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_INVALID], OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_LOST_IN_TRANSIT],OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_DAMAGED] ,OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_LOST_IN_TRANSIT], OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_UNUSABLE], OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_USABLE],OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_DAMAGED]):
+        print "************returnig false staus check"
+        return False
+    if returnOrder.returnAction == ReturnAction.REFUND:
+        returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REFUND_IN_PROCESS]
+    else:
+        returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REPLACEMENT_ORDER_CREATED]
+    detailsMap = {}
+    if returnOrder.refundedAt or returnOrder.replacementOrderId:
+        raise TransactionServiceException(145, "Refund/Replacemet already in Process for this return order")
+    if returnOrder.receivedQuantity != returnOrder.returnQuantity:
+        raise TransactionServiceException(145, "Quantity mismatch Return vs Received")
+    detailsMap['RefundReason'] = returnOrderInfo.refundReason
+    detailsMap['RefundType'] = returnOrderInfo.refundType
+    detailsMap['RefundedBy'] = returnOrderInfo.refundedBy
+    detailsMap['RefundAmount'] = returnOrderInfo.refundAmount
+    detailsMap['RefundDescription'] = returnOrderInfo.refundDescription
+    print detailsMap
+    print "*************************8"
+    if(not __process_return_order(returnOrder, detailsMap)):
+        raise TransactionServiceException(145, "Issue in __process_return_order")
+    returnOrder.processedAt = datetime.datetime.now()
+    __markReturnTransactionAsProcessed(returnOrder.returnTransaction_id)
+    set_order_attributes(returnOrder.orderId, attrList)
+    return True
+def __markReturnTransactionAsProcessed(returnTransactionId):
+    returnTransaction = ReturnTransaction.get_by(id=returnTransactionId)
+    if returnTransaction is None:
+        raise TransactionServiceException(101, "No Return Transaction Found")
+    unprocessedOrders = []
+    for retOrder in returnTransaction.returnOrders:
+        if retOrder.reshippedAt is None and retOrder.refundedAt is None:
+            unprocessedOrders.append(retOrder)
+    if len(unprocessedOrders) == 0:
+        returnTransaction.processedAt = datetime.datetime.now()
+        returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[ReturnTransactionStatus.PROCESSED]
+        session.commit()
 def get_return_orders_info_map(order_ids=None, statuses=None):
     returnOrdersInfoQuery = ReturnOrderInfo.query
     if order_ids is not None and len(order_ids)>0:
         returnOrdersInfoQuery = returnOrdersInfoQuery.filter(ReturnOrderInfo.orderId.in_(tuple(order_ids)))
     if statuses is not None:
 def get_return_transaction(transaction_id):
     transaction = ReturnTransaction.get_by(id=transaction_id)
     if not transaction:
         raise TransactionServiceException(108, "no such transaction")
     return transaction
 def get_return_orders_for_return_transaction(returnTransactionId):
     returnOrders = ReturnOrderInfo.query.filter_by(returnTransactionId=returnTransactionId).all()
         returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[new_status]
     elif new_status == ReturnTransactionStatus.PROCESSED:
         if returnOrdersIds and len(returnOrdersIds)>0:
             unprocessedOrders = []
             for retOrder in returnTransaction.returnOrders:
-                if retOrder.reshippedAt is None and retOrder.refundedAt is None:
+                if retOrder.reshippedAt is None or retOrder.refundedAt is None:
                     unprocessedOrders.append(retOrder)
             if len(returnOrdersIds) < len(returnTransaction.returnOrders):
                 if len(returnOrdersIds) == len(unprocessedOrders):
                     for ret_Order in unprocessedOrders:
                         if ret_Order.returnAction == ReturnAction.REFUND:
                     else:
                         ret_Order.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REPLACEMENT_ORDER_CREATED]
                 returnTransaction.processedAt = datetime.datetime.now()
                 returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[new_status]
             for returnOrderId in returnOrdersIds:
                 __process_return_order(get_return_order_info(returnOrderId), returnOrdersAttrMap.get(returnOrderId))
+    elif new_status == ReturnTransactionStatus.COMPLETED:
+        mark_return_transaction_complete(returnTransaction.id)
+    elif new_status == ReturnTransactionStatus.CLOSED:
-    elif new_status == ReturnTransactionStatus.CLOSED and mark_return_transaction_complete(returnTransaction.id):
+        if not returnTransaction.status == ReturnTransactionStatus._VALUES_TO_NAMES[ReturnTransactionStatus.COMPLETED]:
+            raise
         returnTransaction.closedAt = datetime.datetime.now()
         for ret_Order in returnTransaction.returnOrders:
             ret_Order.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.CLOSED]
         __communicate_customer_for_closed_transaction(returnTransaction)
         returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[new_status]
     session.commit()
     return True
-def create_return_pickup_request(returnOrderIds, providerId):
+def create_return_pickup_request(returnOrderIds):
     returnPickupRequest = ReturnPickupRequest()
-    returnPickupRequest.logisticsProviderId = providerId
-    returnPickupRequest.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_REQUESTED]
+    returnPickupRequest.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PENDING]
     if len(returnOrderIds) > 0:
         for returnOrderId in returnOrderIds:
             returnOrder = get_return_order_info(returnOrderId)
             returnOrder.logisticsRequestId = returnPickupRequest.id
         session.commit()
-        return True
+        return returnPickupRequest.id
-    return False
+    return 0
 def update_return_pickup_request(returnPickupRequest):
+    print returnPickupRequest
     try:
         returnPickupReq = ReturnPickupRequest.get_by(id=returnPickupRequest.id)
+        if returnPickupRequest.pickupStatus == ReturnTxnPickupStatus.PICKUP_REQUESTED:
+            returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[returnPickupRequest.pickupStatus]
-        if returnPickupRequest.pickupRequestNo:
+        if returnPickupRequest.pickupStatus == ReturnTxnPickupStatus.PICKUP_CONFIRMED:
+            returnPickupReq.logisticsProviderId = returnPickupRequest.logisticsProviderId
             returnPickupReq.pickupRequestNo = returnPickupRequest.pickupRequestNo
             returnPickupReq.confirmedAt = datetime.datetime.now()
-            returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_CONFIRMED]
+            returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[returnPickupRequest.pickupStatus]
             for returnOrder in ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupRequest.id).all():
                 if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_PICKUP_REQUEST_RAISED]:
                     returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_PICKUP_CONFIRMED]
                 else:
                     returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PICKUP_CONFIRMED]
         if returnPickupRequest.pickupStatus == ReturnTxnPickupStatus.PICKUP_SCHEDULED:
             returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[returnPickupRequest.pickupStatus]
-            returnPickupReq.promised_pickup_timestamp = datetime.datetime.now()+timedelta(days=2)
+            returnPickupReq.promised_pickup_timestamp = to_py_date(returnPickupRequest.promised_pickup_timestamp)
             returnOrdersMap = {}
             returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupRequest.id).all()
             for returnOrder in returnOrders:
                 returnTxn = returnOrders[0].returnTransaction
                 if returnOrdersMap.has_key(returnTxn.address_id):
             for returnOrdersList in returnOrdersMap.values():
                 try:
                     communicate_pickup_details_to_customer(returnPickupReq, returnOrdersList)
                 except:
                     print "Customer Communication Failed for the pickup Information"
-        if returnPickupRequest.pickedUpAt:
+        if returnPickupRequest.pickupStatus == ReturnTxnPickupStatus.PICKUP_IN_TRANSIT:
             returnPickupReq.pickedUpAt = to_py_date(returnPickupRequest.pickedUpAt)
             returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_IN_TRANSIT]
             for returnOrder in ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupRequest.id).all():
                 if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_PICKUP_CONFIRMED]:
                     returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RETURN_IN_TRANSIT]
                 else:
+                    returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RETURN_IN_TRANSIT]
+        if returnPickupRequest.pickupStatus == ReturnTxnPickupStatus.PICKUP_RECEIVED:
+            returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_RECEIVED]
+            for returnOrder in ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupRequest.id).all():
-                    returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RETURN_IN_TRANSIT]
+                if returnOrder.returnStatus not in (OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_VALID], OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_INVALID], OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_LOST_IN_TRANSIT], OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_DAMAGED],OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_VALID],OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_LOST_IN_TRANSIT], OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_UNUSABLE], OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_USABLE], OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_DAMAGED]):
+                    return False
+                returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.QUALITY_CHECK]
         session.commit()
         return True
     except:
+        traceback.print_exc()
         return False
 def receive_return_pickup(returnOrdersMap, req_id):
-    returnPickupReq = ReturnPickupRequest.get_by(id=req_id)
+    #returnPickupReq = ReturnPickupRequest.get_by(id=req_id)
-    returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==req_id).all()
+    #returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==req_id).all()
-    if len(returnOrders)!=len(returnOrdersMap.keys()):
+    #if len(returnOrders)!=len(returnOrdersMap.keys()):
-        raise TransactionServiceException(101, "All Returns Orders  Information Missing. Please Fill All Orders Info")
+    #    raise TransactionServiceException(101, "All Returns Orders  Information Missing. Please Fill All Orders Info")
-    for returnOrder in returnOrders:
+    for returnOrderId in returnOrdersMap.iterkeys():
+        returnOrder = ReturnOrderInfo.get_by(id=returnOrderId)
+        if returnOrder is None:
+            raise TransactionServiceException(101, "Return order missing")
         returnOrderDetails = returnOrdersMap.get(returnOrder.id)
         receiveCondition = ReceivedReturnType._NAMES_TO_VALUES[returnOrderDetails.get('ReceiveCondition')]
         quantity = int(returnOrderDetails.get('Quantity'))
+        returnOrder.receivedReturnType = receiveCondition
+        returnOrder.receivedReturnType = receiveCondition
-        if returnOrder.returnStatus in [OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_PICKUP_CONFIRMED], OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_RETURN_IN_TRANSIT]]:
+        if returnOrder.returnStatus in [OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_PICKUP_CONFIRMED], OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RETURN_IN_TRANSIT]]:
             if receiveCondition == ReceivedReturnType.PRESTINE:
-                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_RECEIVED_PRESTINE]
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_PRESTINE]
             elif receiveCondition == ReceivedReturnType.DAMAGED:
-                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_RECEIVED_DAMAGED]
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_DAMAGED]
             elif receiveCondition == ReceivedReturnType.LOST_IN_TRANSIT:
-                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_LOST_IN_TRANSIT]
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_LOST_IN_TRANSIT]
             returnOrder.receivedAt = datetime.datetime.now()
             returnOrder.receivedQuantity = quantity
-        elif returnOrder.returnStatus in [OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_PICKUP_CONFIRMED], OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_RETURN_IN_TRANSIT]]:
+        elif returnOrder.returnStatus in [OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PICKUP_CONFIRMED], OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RETURN_IN_TRANSIT]]:
             if receiveCondition == ReceivedReturnType.PRESTINE:
-                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_RECEIVED_PRESTINE]
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_PRESTINE]
             elif receiveCondition == ReceivedReturnType.DAMAGED:
-                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_RECEIVED_DAMAGED]
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_DAMAGED]
             elif receiveCondition == ReceivedReturnType.LOST_IN_TRANSIT:
-                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_LOST_IN_TRANSIT]
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_LOST_IN_TRANSIT]
             returnOrder.receivedAt = datetime.datetime.now()
             returnOrder.receivedQuantity = quantity
         else:
             return False
             "RET_RECEIVED_PRESTINE" : ScanType.SALE_RET,
             "RET_RECEIVED_DAMAGED"  : ScanType.SALE_RET_UNUSABLE,
             "RET_LOST_IN_TRANSIT"   : ScanType.LOST_IN_TRANSIT,
             "DOA_RECEIVED_PRESTINE" : ScanType.DOA_IN,
             "DOA_RECEIVED_DAMAGED"  : ScanType.DOA_IN,
-            "DOA_LOST_IN_TRANSI"   : ScanType.LOST_IN_TRANSIT
+            "DOA_LOST_IN_TRANSIT"   : ScanType.LOST_IN_TRANSIT
+        }
-    inventoryClient = InventoryClient().get_client()
+    #inventoryClient = InventoryClient().get_client()
-    warehouse = inventoryClient.getWarehouse(returnOrders[0].warehouse_id)
+    #warehouse = inventoryClient.getWarehouse(returnOrder.warehouse_id)
-    warehouseClient = WarehouseClient().get_client()
+    #warehouseClient = WarehouseClient().get_client()
-    for returnOrder in returnOrders:
+    for returnOrderId in returnOrdersMap.iterkeys():
+        returnOrder = ReturnOrderInfo.get_by(id=returnOrderId)
         returnOrderDetails = returnOrdersMap.get(returnOrder.id)
-        warehouse = None
+        #warehouse = inventoryClient.getWarehouse(returnOrder.warehouse_id)
         serialNumbers = []
         if returnOrderDetails.has_key('SerialNumbers'):
-            serialNumbers = returnOrderDetails.get('SerialNumbers').split(',')
+            serialNumbersSplitted = returnOrderDetails.get('SerialNumbers').split(',')
+            serialNumbers = []
+            for t in serialNumbersSplitted:
+                if t.strip() !="":
+                    serialNumbers.append(t.strip())
         scanFreebie = False
         if returnOrderDetails.has_key('ScanFreebie') and returnOrderDetails.get('ScanFreebie')=='yes':
             scanFreebie = True
         quantity = int(returnOrderDetails.get('Quantity'))
-        if warehouse is not None and warehouse.billingType == BillingType.OURS or warehouse.billingType == BillingType.OURS_EXTERNAL:
+#         if warehouse is not None and warehouse.billingType == BillingType.OURS or warehouse.billingType == BillingType.OURS_EXTERNAL:
-            if scanMap.has_key(returnOrder.returnStatus):
+#             if scanMap.has_key(returnOrder.returnStatus):
-                scanType = scanMap[returnOrder.returnStatus]
+#                 scanType = scanMap[returnOrder.returnStatus]
-                lineitem = returnOrder.lineitem
+#                 lineitem = returnOrder.lineitem
-                return_qty = lineitem.returnQty - returnOrder.returnQuantity + quantity
+#                 return_qty = lineitem.returnQty - returnOrder.returnQuantity + quantity
-                lineitem.returnQty = lineitem.returnQty - returnOrder.returnQuantity + quantity
+#                 lineitem.returnQty = lineitem.returnQty - returnOrder.returnQuantity + quantity
-                order = get_order(returnOrder.orderId)
+#                 order = get_order(returnOrder.orderId)
-                if return_qty < order.lineitems[0].quantity:
+#                 if return_qty < order.lineitems[0].quantity:
-                    order.status = OrderStatus.PARTIAL_RETURN
+#                     order.status = OrderStatus.PARTIAL_RETURN
-                if return_qty == order.lineitems[0].quantity:
+#                 if return_qty == order.lineitems[0].quantity:
-                    order.status = OrderStatus.COMPLETE_RETURN
+#                     order.status = OrderStatus.COMPLETE_RETURN
-                if warehouse.billingType == BillingType.OURS or scanType != ScanType.SALE_RET:
+#                 if warehouse.billingType == BillingType.OURS or scanType != ScanType.SALE_RET:
-                    if lineitem.serial_number is not None:
+#                     if lineitem.serial_number is not None:
-                        if serialNumbers is None or len(serialNumbers)==0 or len(serialNumbers)<quantity:
+#                         if serialNumbers is None or len(serialNumbers)==0 or len(serialNumbers)<quantity:
-                            return False
+#                             return False
-                        else:
+#                         else:
-                            for serialNumber in serialNumbers:
+#                             for serialNumber in serialNumbers:
-                                try:
+#                                 try:
-                                    warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
+#                                     warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
-                                except:
+#                                 except:
-                                    warehouseClient = WarehouseClient().get_client()
+#                                     warehouseClient = WarehouseClient().get_client()
-                                    warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
+#                                     warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
-                    else:
+#                     else:
-                        try:
+#                         try:
-                            warehouseClient.scanForOrder(None, scanType, quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
+#                             warehouseClient.scanForOrder(None, scanType, quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
-                        except:
+#                         except:
-                            warehouseClient = WarehouseClient().get_client()
+#                             warehouseClient = WarehouseClient().get_client()
-                            warehouseClient.scanForOrder(None, scanType, quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
+#                             warehouseClient.scanForOrder(None, scanType, quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
-                if warehouse.billingType == BillingType.OURS_EXTERNAL and scanType == ScanType.SALE_RET:
+#                 if warehouse.billingType == BillingType.OURS_EXTERNAL and scanType == ScanType.SALE_RET:
-                    try:
+#                     try:
-                        warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
+#                         warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
-                    except:
+#                     except:
-                        warehouseClient = WarehouseClient().get_client()
+#                         warehouseClient = WarehouseClient().get_client()
-                        warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
+#                         warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
-                if scanFreebie:
+#                 if scanFreebie:
-                    try:
+#                     try:
-                        warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
+#                         warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
-                    except:
+#                     except:
-                        warehouseClient = WarehouseClient().get_client()
+#                         warehouseClient = WarehouseClient().get_client()
-                        warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
+#                         warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
+#
+        isValid = returnOrderDetails.get('productUsable')
-    returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_RECEIVED]
+        if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_PRESTINE]:
+            if isValid == "true":
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_VALID]
+            else:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_INVALID]
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_PRESTINE]:
+            if isValid == "true":
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_USABLE]
+            else:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_UNUSABLE]
     session.commit()
     return True
 def validate_return_pickup(returnPickupId, returnOrdersMap):
     returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupId).all()
     if len(returnOrders)!=len(returnOrdersMap.keys()):
         raise TransactionServiceException(101, "All Returns Orders Information Missing. Please Fill All Orders Info")
     if not overrideWarranty and itemCondition is not None:
         if itemCondition == 'DAMAGED':
             query = query.filter(LineItem.damaged_expiry_timestamp > datetime.datetime.now())
         elif itemCondition == 'DEFECTIVE':
             query = query.filter(LineItem.warranty_expiry_timestamp > datetime.datetime.now())
     orders = query.order_by(desc(Order.delivery_timestamp)).all()
     return orders
 def get_eligible_return_orders_for_pickup(customerId):
     return session.query(ReturnOrderInfo).join((ReturnTransaction,ReturnOrderInfo.returnTransaction_id==ReturnTransaction.id)).filter(ReturnTransaction.customer_id==customerId).filter(or_(ReturnOrderInfo.returnStatus==OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PICKUP_REQUEST_RAISED], ReturnOrderInfo.returnStatus==OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_PICKUP_REQUEST_RAISED])).filter(ReturnOrderInfo.logisticsRequestId==None).all()
 def validate_return_transaction(customerId, returnOrdersMap, itemCondition, overrideWarranty):
     eligibleOrders = get_eligible_orders_for_return(customerId, itemCondition, overrideWarranty)
     ordersMap = {}
     for order in eligibleOrders:
         ordersMap[order.id] = order.lineitems[0].quantity - order.lineitems[0].returnQty
     for orderId, returnOrderQty in returnOrdersMap.items():
         if returnOrderQty > ordersMap.get(orderId):
             return False
     return True
 def get_return_pickup_request(returnPickupId):
     return ReturnPickupRequest.get_by(id=returnPickupId)
+def mark_return_not_required_orders_as_processed(t_returnOrderInfo):
+    returnOrderInfo = ReturnOrderInfo.get_by(id=t_returnOrderInfo.id)
+    if returnOrderInfo is None:
+        raise TransactionServiceException(101, "No Return Order Found")
+    if returnOrderInfo.returnPickupType == ReturnPickupType.NOT_REQUIRED:
+        if returnOrderInfo.returnAction == ReturnAction.REPLACEMENT  or t_returnOrderInfo.refundType!= RefundType.WALLET:
+            raise TransactionServiceException(101, "Refund Type not Defined for return order:- "+str(returnOrderInfo.id))
+    detailsMap = {}
+    if returnOrderInfo.refundedAt :
+        raise TransactionServiceException(145, "Refund already in Process for this return order")
+    detailsMap['RefundReason'] = "As per Customer Request"
+    detailsMap['RefundType'] = t_returnOrderInfo.refundType
+    detailsMap['RefundedBy'] = t_returnOrderInfo.refundedBy
+    detailsMap['RefundAmount'] = t_returnOrderInfo.refundAmount
+    returnOrderInfo.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REFUND_IN_PROCESS]
+    if(not __process_return_order(returnOrderInfo, detailsMap)):
+        raise TransactionServiceException(145, "Issue in __process_return_order")
+    returnOrderInfo.processedAt = datetime.datetime.now()
+    returnOrderInfo.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REFUND_DONE]
+    session.commit()
+    __markReturnTransactionAsProcessed(returnOrderInfo.returnTransaction_id)
+    return True
-def mark_return_not_required_orders_as_processed(returnTransactionId):
-    returnTransaction = ReturnTransaction.get_by(id=returnTransactionId)
-    if returnTransaction is None:
-        raise TransactionServiceException(101, "No Return Transaction Found")
-    eligibleOrders = []
-    for returnOrder in returnTransaction.returnOrders:
-        if returnOrder.returnPickupType == ReturnPickupType.NOT_REQUIRED:
-            if returnOrder.returnAction and returnOrder.refundType == RefundType.INIT:
-                raise TransactionServiceException(101, "Refund Type not Defined for return order:- "+str(returnOrder.id))
-            eligibleOrders.append(returnOrder)
-    returnOrdersAttrMap = {}
-    returnOrderIds = []
-    for returnOrder in eligibleOrders:
-        returnOrderIds.append(returnOrder.id)
-        if returnOrder.returnAction:
-            detailsMap = {}
-            if returnOrder.refundedAt:
-                raise TransactionServiceException(145, "Refund already in Process for this return order")
-            detailsMap['RefundReason'] = "As per Customer Request"
-            detailsMap['RefundType'] = returnOrder.refundType
-            detailsMap['RefundedBy'] = "CRM Executive"
-            detailsMap['RefundAmount'] = returnOrder.refundAmount
-            returnOrdersAttrMap[returnOrder.id] = detailsMap
-    return change_return_transaction_status(returnTransactionId, ReturnTransactionStatus.PROCESSED, returnOrderIds, returnOrdersAttrMap)
 def get_all_return_orders_for_return_pickup_request(logisticsRequestId):
     return ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==logisticsRequestId).all()
-def __clone_return_order(returnOrder, splitReturnOrderQty):
+def __clone_return_order(returnOrder, splitOrderQty):
+    if returnOrder.returnQuantity <= splitOrderQty or splitOrderQty<=0:
+        raise TransactionServiceException(101, "SplitQty canot be equal to or greater than parent return order returnQty")
+    returnOrder.returnQuantity = returnOrder.returnQuantity - splitOrderQty
-    new_returnOrder = ReturnOrderInfo()
+    new_return_order = ReturnOrderInfo()
+    new_return_order.returnTransaction = returnOrder.returnTransaction
+    new_return_order.masterOrderId = returnOrder.masterOrderId
-    returnOrderInfo.orderId = returnOrder.orderId
+    new_return_order.orderId = returnOrder.orderId
-    returnOrderInfo.lineItemId = returnOrder.lineItemId
+    new_return_order.lineItemId = returnOrder.lineItemId
+    new_return_order.logisticsRequestId = returnOrder.logisticsRequestId
-    returnOrderInfo.returnQuantity = splitReturnOrderQty
+    new_return_order.returnQuantity = splitOrderQty
+    new_return_order.receivedQuantity = returnOrder.receivedQuantity
-    returnOrderInfo.createdAt = datetime.datetime.now()
+    new_return_order.createdAt = returnOrder.createdAt
-    if itemCondition=="DAMAGED":
+    new_return_order.processedAt = returnOrder.processedAt
-        returnOrderInfo.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_REQUEST_RECEIVED]
+    new_return_order.returnStatus = returnOrder.returnStatus
-    else:
+    new_return_order.reshippedAt = returnOrder.reshippedAt
+    new_return_order.receivedAt = returnOrder.receivedAt
-        returnOrderInfo.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_REQUEST_RECEIVED]
+    new_return_order.refundReason = returnOrder.refundReason
+    new_return_order.refundedBy = returnOrder.refundedBy
-    returnOrderInfo.masterOrderId = order.logisticsTransactionId
+    new_return_order.refundedAt = returnOrder.refundedAt
-    returnOrderInfo.warehouse_id = order.warehouse_id
+    new_return_order.warehouse_id = returnOrder.warehouse_id
+    new_return_order.refundAmount = returnOrder.refundAmount
+    new_return_order.refundType = returnOrder.refundType
-    returnOrderInfo.returnAction = returnInfo.returnAction
+    new_return_order.refundDescription = returnOrder.refundDescription
+    new_return_order.returnPickupType = returnOrder.returnPickupType
+    new_return_order.shippingType = returnOrder.shippingType
+    new_return_order.replacementOrderId = returnOrder.replacementOrderId
+    new_return_order.receivedReturnType = returnOrder.receivedReturnType
-    returnOrderInfo.freebieItemId = order.freebieItemId
+    new_return_order.freebieItemId = returnOrder.freebieItemId
+    new_return_order.returnAction = returnOrder.returnAction
-    returnOrderInfo.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.PENDING]
+    new_return_order.returnTxnResolutionStatus = returnOrder.returnTxnResolutionStatus
+    new_return_order.lineitem = returnOrder.lineitem
+    new_return_order.returnPickUpRequest = returnOrder.returnPickUpRequest
+    return new_return_order
 def get_seller_info(sellerId):
     sellerInfo = SellerInfo()
     seller = Seller.get_by(id=sellerId)
     if seller is None:
 def get_warehouse_address(addressId):
     address = WarehouseAddressMaster.get_by(id=addressId)
     return to_t_warehouse_address(address)
-def split_return_order_info(returnOrderId, splitReturnOrderQty):
+def split_return_order_info(returnOrderId, splitOrderQty):
     returnOrder = ReturnOrderInfo.get_by(id=returnOrderId)
     if returnOrder is None:
         raise TransactionServiceException(101, "No Return Order is there with this Order Id")
+    new_return_order = __clone_return_order(returnOrder, splitOrderQty)
+    session.commit()
+    return new_return_order
 #Seller would be used to get tin number
 def __get_seller(warehouse_id):
-        #As of now we have hardcoded the company and
+    #As of now we have hardcoded the company and
-        #seller would be returned on basis warehouse and company
+    #seller would be returned on basis warehouse and company
-        orgId=2
+    orgId=2
-        (sellerId,) = session.query(Seller.id).join((SellerWarehouse, Seller.id==SellerWarehouse.seller_id)).filter(Seller.organisation_id==orgId).filter(SellerWarehouse.warehouse_id==warehouse_id).first()
+    (sellerId,) = session.query(Seller.id).join((SellerWarehouse, Seller.id==SellerWarehouse.seller_id)).filter(Seller.organisation_id==orgId).filter(SellerWarehouse.warehouse_id==warehouse_id).first()
-        return sellerId
+    return sellerId
 def add_shipment_delay(shipmentDelayDetail):
     returnList = []
     for delayObj in shipmentDelayDetail:
-        print delayObj.orderId
-        print delayObj.delayReason
-        print delayObj.delayReasonText
-        print delayObj.delay
         order = get_order(delayObj.orderId)
         if order.status not in [OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.ACCEPTED]:
             returnList.append(delayObj.orderId)
             continue
         try:
             returnList.append(delayObj.orderId)
             continue
         if not result:
             returnList.append(delayObj.orderId)
     return returnList
 #Buyer can be anyone based on logic
 def __get_buyer(warehouse_id):
         #As of now we have hardcoded the company and
         #seller would be returned on basis warehouse and company

Subversion Repositories SmartDukaan

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