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

 from elixir import *
 from math import ceil
 from random import randrange
 from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
 from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
-from reportlab.lib.units import inch
+from reportlab.lib.units import inch, mm
 from reportlab.pdfgen.canvas import Canvas
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, \
     BaseDocTemplate, Frame, PageTemplate
 from reportlab.rl_config import defaultPageSize
+from reportlab.lib import colors
+from reportlab.platypus import Table, TableStyle
 from shop2020.clients.AlertClient import AlertClient
 from shop2020.clients.CRMClient import CRMClient
 from shop2020.clients.CatalogClient import CatalogClient
 from shop2020.clients.HelperClient import HelperClient
 from shop2020.clients.InventoryClient import InventoryClient
     FRC, OperatorSeries, SourceDetail, Company, EbayOrder, AmazonFbaSalesSnapshot, \
     AmazonOrder, StoreOrderDetail, EdcBank, StoreOrderCollection, \
     HotspotServiceMatrix, SnapdealOrder, FlipkartOrder, DataInsuranceDetailForOrder, \
     AmazonFbaOrderReturns, FlipkartAdvantageOrder, InvoiceCounterGenerator, \
     TransactionShipmentSequence, HsOrder, Creditor, UserSanction, CreditHistory, LoanHistory, \
-    ShipmentLogisticsCostDetail
+    ShipmentLogisticsCostDetail, ReturnOrderInfo, ReturnTransaction , ReturnPickupRequest
 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 \
     TransactionStatus, OrderStatus, DelayReason, ExtraTransactionProcessingType, \
     HotspotAction, TimeoutSummary, OrderStatusGroups, OrderType, RechargeOrderStatus, \
     RechargeType, RechargeStatistics, DeviceNumberInfo, EmiChargeType, PayMethod, \
     OrderSource, StorePaymentStatus, ProductCondition, TaxType, \
     AmazonFCWarehouseLocation, RechargeMode, CreditTxnType, CreditHistory as TCreditHistory, \
-    LoanHistory as TLoanHistory, ShipmentLogisticsCostDetail as TShipmentLogisticsCostDetail
+    LoanHistory as TLoanHistory, ShipmentLogisticsCostDetail as TShipmentLogisticsCostDetail, \
+    ReturnTransactionStatus, ReturnAction, ReturnTxnResolutionStatus, ReplacementShippingType, \
+    ReturnTxnPickupStatus, ReceivedReturnType, ReturnPickupType
 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, \
     pdf.drawText(order_text)
     pdf.showPage()
     pdf.save()
     return filename
+def __coord(self, x, y, unit=1):
+        """
+        # http://stackoverflow.com/questions/4726011/wrap-text-in-a-table-reportlab
+        Helper class to help position flowables in Canvas objects
+        """
+        x, y = x * unit, PAGE_HEIGHT -  y * unit
+        return x, y
+def __generate_return_transaction_invoice(returnOrders, warehouse, provider, filename):
+    ReturnPickupRequest
+    if warehouse.id == 7:
+        executive = 'Varun Patiyal'
+    else:
+        executive = 'Deepak Kumar'
+    pdf = Canvas(filename)
+    styles = getSampleStyleSheet()
+    address = """ <font size="9">
+        To<br/>
+        <br/>
+        %s<br/>"""%(executive)
+    for line in warehouse.location.split("\n"):
+        address = address +"""%s<br/>"""%(line)
+    address = address +"""PIN %s<br>"""%(warehouse.pincode)
+    address = address +"""</font>"""
+    p = Paragraph(address, styles["Normal"])
+    p.wrapOn(pdf, PAGE_WIDTH, PAGE_HEIGHT)
+    p.drawOn(pdf, *__coord(18, 40, mm))
+    returnPickupReq = ReturnPickupRequest.get_by(id=returnOrders[0].logisticsRequestId)
+    order_number = '<font size="14"><b>Return Pickup Request No:- %s </b></font>' % returnPickupReq.pickupRequestNo
+    p = Paragraph(order_number, styles["Normal"])
+    p.wrapOn(pdf, PAGE_WIDTH, PAGE_HEIGHT)
+    p.drawOn(pdf, *__coord(18, 50, mm))
+    data = []
+    data.append(["Content", "Quantity", "Declared Value: Rs.", "Order ID", "Return Ticket Id"])
+    for returnOrder in returnOrders:
+        lineitem = returnOrder.lineitem
+        row = []
+        row.append(str(lineitem))
+        row.append(returnOrder.returnQuantity)
+        row.append(returnOrder.returnQuantity*lineitem.unit_price)
+        row.append(returnOrder.orderId)
+        row.append(returnOrder.returnTransaction.id)
+        data.append(row)
+    t = Table(data, 1.5 * inch)
+    t.setStyle(TableStyle([
+        ('INNERGRID', (0,0), (-1,-1), 0.25, colors.black),
+        ('BOX', (0,0), (-1,-1), 0.25, colors.black)
+    ]))
+    t.wrapOn(pdf, PAGE_WIDTH, PAGE_HEIGHT)
+    t.drawOn(pdf, *__coord(18, 85, mm))
+    pdf.showPage()
+    pdf.save()
+    return filename
 def __push_store_collection_to_hotspot(order, ctype, cashamount, cardamount):
     ts = datetime.datetime.now()
     store =  get_hotspot_store(order.storeId, "")
     soc = StoreOrderCollection()
     ordersList[0].lineitems[0].logisticsCost = ordersList[0].lineitems[0].logisticsCost + (round(logisticsCost,2)-logisticsCostInOrders)
     if codCollectionCharges>0:
         ordersList[0].lineitems[0].codCollectionCharges = ordersList[0].lineitems[0].codCollectionCharges + (round(codCollectionCharges,2)-codCollectionChargesInOrders)
     session.commit()
     return ordersList
+def __create_return_order_info(order, status, quantity=0):
+    returnOrderInfo = ReturnOrderInfo()
+    returnOrderInfo.orderId = order.id
+    returnOrderInfo.lineItemId = order.lineitems[0].id
+    if quantity>0:
+        returnOrderInfo.returnQuantity = quantity
+    else:
+        returnOrderInfo.returnQuantity = order.lineitems[0].quantity
+    returnOrderInfo.createdAt = datetime.datetime.now()
+    returnOrderInfo.returnStatus = status
+    returnOrderInfo.masterOrderId = order.logisticsTransactionId
+    returnOrderInfo.warehouse_id = order.warehouse_id
+    session.commit()
+    return returnOrderInfo
+def create_return_order_info(returnInfo):
+    returnOrderInfo = ReturnOrderInfo()
+    returnOrderInfo.orderId = returnInfo.orderId
+    returnOrderInfo.lineItemId = returnInfo.lineItemId
+    returnOrderInfo.returnQuantity = returnInfo.returnQuantity
+    returnOrderInfo.createdAt = datetime.datetime.now()
+    returnOrderInfo.returnStatus = returnInfo.returnStatus
+    returnOrderInfo.masterOrderId = returnInfo.masterOrderId
+    returnOrderInfo.warehouse_id = returnInfo.warehouse_id
+    returnOrderInfo.returnAction = ReturnAction._VALUES_TO_NAMES[returnInfo.returnAction]
+    returnOrderInfo.shippingType = ReplacementShippingType._VALUES_TO_NAMES[returnInfo.shippingType]
+    returnOrderInfo.freebieItemId = returnInfo.freebieItemId
+    returnOrderInfo.returnAction = returnOrderInfo.returnAction
+    returnOrderInfo.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.PENDING]
+    session.commit()
+    return returnOrderInfo
+def get_return_order_info(returnOrderId):
+    returnOrder = ReturnOrderInfo.get_by(id=returnOrderId)
+    if not returnOrder:
+        return None
+    return order
+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:
+        returnOrdersInfoQuery = returnOrdersInfoQuery.filter(ReturnOrderInfo.returnStatus.in_(tuple(statuses)))
+    allReturnOrdersList = returnOrdersInfoQuery.all()
+    returnOrdersInfoMap = {}
+    for returnOrder in allReturnOrdersList:
+        if returnOrdersInfoMap.has_key(returnOrder.orderId):
+            returnList = returnOrdersInfoMap.get(returnOrder.orderId)
+            returnList.append(returnOrder)
+            returnOrdersInfoMap[returnOrder.orderId] = returnList
+        else:
+            returnList = []
+            returnList.append(returnOrder)
+            returnOrdersInfoMap[returnOrder.orderId] = returnList
+    return returnOrdersInfoMap
+def update_return_order_info(returnInfo):
+    try:
+        returnOrderInfo = get_return_order_info(returnInfo.id)
+        returnOrderInfo.returnStatus = returnInfo.returnStatus
+        if returnInfo.processedAt:
+            returnOrderInfo.processedAt = to_py_date(returnInfo.processedAt)
+        if returnInfo.reshippedAt:
+            returnOrderInfo.reshippedAt = to_py_date(returnInfo.reshippedAt)
+        if returnInfo.receivedAt:
+            returnOrderInfo.receivedAt = to_py_date(returnInfo.receivedAt)
+        if returnInfo.authorizedAt:
+            returnOrderInfo.authorizedAt = to_py_date(returnInfo.authorizedAt)
+        if returnInfo.refundAmount:
+            returnOrderInfo.refundAmount = returnInfo.refundAmount
+        if returnInfo.refundReason:
+            returnOrderInfo.refundReason = returnInfo.refundReason
+        if returnInfo.refundedAt:
+            returnOrderInfo.refundedAt = to_py_date(returnInfo.refundedAt)
+        if returnInfo.refundedBy:
+            returnOrderInfo.refundedBy = returnInfo.refundedBy
+        if returnInfo.refundType:
+            returnOrderInfo.refundType = returnInfo.refundType
+        if returnInfo.refundDescription:
+            returnOrderInfo.refundDescription = returnInfo.refundDescription
+        if returnInfo.logisticsRequestId:
+            returnOrderInfo.logisticsRequestId = returnInfo.logisticsRequestId
+        if returnOrderInfo.shippingType != returnInfo.shippingType:
+            returnOrderInfo.shippingType = returnInfo.shippingType
+            if returnOrderInfo.replacementOrderId and returnInfo.shippingType:
+                replacementorder = get_order(returnOrderInfo.replacementOrderId)
+                replacementorder.promised_shipping_time = None
+                replacementorder.promised_delivery_time = None
+                replacementorder.transaction = None
+                replacementorder.expected_delivery_time = None
+                replacementorder.expected_shipping_time = None
+        if returnInfo.replacementOrderId:
+            returnOrderInfo.replacementOrderId = returnInfo.replacementOrderId
+        if returnOrderInfo.returnPickupType != returnInfo.returnPickupType:
+            if returnOrderInfo.logisticsRequestId:
+                returnpickupRequest = ReturnPickupRequest.get_by(id=returnOrderInfo.logisticsRequestId)
+                if returnpickupRequest.pickupStatus in ['PICKUP_REQUESTED','PENDING']:
+                    returnOrderInfo.returnPickupType = returnInfo.returnPickupType
+            else:
+                returnOrderInfo.returnPickupType = returnInfo.returnPickupType
+        else:
+            return False
+        if returnOrderInfo.returnAction != returnInfo.returnAction:
+            returnOrderInfo.returnAction = returnInfo.returnAction
+        session.commit()
+        return True
+    except:
+        return False
+def bulk_update_return_order_info(orderReturnInfosMap):
+    responseMap = {}
+    for orderId, returnOrdersList in orderReturnInfosMap.items():
+        for returnOrder in returnOrdersList:
+            response = update_return_order_info(returnOrder)
+            responseMap[orderId] = response
+    return responseMap
+def get_return_orders_as_per_warehouse(warehouseId):
+    all_return_orders_as_per_warehouse = ReturnOrderInfo.query.filter(ReturnOrderInfo.processedAt==None).filter(ReturnOrderInfo.warehouse_id <= warehouseId).all()
+    if all_return_orders_as_per_warehouse is None:
+        all_return_orders_as_per_warehouse = []
+    return all_return_orders_as_per_warehouse
+def create_return_transaction(returnTransaction):
+    t_orders = returnTransaction.returnOrders
+    if not t_orders:
+        raise TransactionServiceException(101, "Return Orders missing from the transaction")
+    returnTxn = ReturnTransaction()
+    returnTxn.customer_id = returnTransaction.customer_id
+    returnTxn.status = ReturnTransactionStatus._VALUES_TO_NAMES[ReturnTransactionStatus.INITIATED]
+    returnTxn.customer_email = returnTransaction.customer_email
+    returnTxn.customer_name = returnTransaction.customer_name
+    returnTxn.customer_id = returnTransaction.customer_id
+    returnTxn.createdAt = datetime.datetime.now()
+    returnTxn.address_id = returnTransaction.address_id
+    returnTxn.ticketId = returnTransaction.ticketId
+    returnTxn.customerAddress = returnTransaction.customerAddress
+    returnTxn.customerCity = returnTransaction.customerCity
+    returnTxn.customerPhone = returnTransaction.customerPhone
+    returnTxn.customerState = returnTransaction.customerState
+    returnTxn.pincode = returnTransaction.pincode
+    for t_order in t_orders:
+        returnOrder = create_return_order_info(t_order)
+        returnOrder.returnTransaction = returnTxn
+        order = get_order(returnOrder.orderId)
+        lineitem = order.lineitems[0]
+        lineitem.returnQty = lineitem.returnQty + returnOrder.returnQuantity
+        order.status = OrderStatus.PARTIAL_RETURN_IN_PROCESS
+        order.statusDescription = "Partial Return In Process"
+    session.commit()
+    try:
+        crmServiceClient = CRMClient().get_client()
+        ticket =Ticket()
+        activity = Activity()
+        description = "Creating Ticket for return requested by customer:- " + str(returnTransaction.customer_name)  + " Return Transaction Id:- "+ str(returnTxn.id)
+        ticket.creatorId = 1
+        ticket.assigneeId = 34
+        ticket.category = TicketCategory.RETURN_FORM
+        ticket.priority = TicketPriority.HIGH
+        ticket.status = TicketStatus.OPEN
+        ticket.description = description
+        ticket.orderId = order.id
+        activity.creatorId = 1
+        activity.ticketAssigneeId = ticket.assigneeId
+        activity.type = ActivityType.OTHER
+        activity.description = description
+        activity.ticketCategory = ticket.category
+        activity.ticketDescription = ticket.description
+        activity.ticketPriority = ticket.priority
+        activity.ticketStatus = ticket.status
+        ticket.customerId= returnTransaction.customer_id
+        ticket.customerEmailId = returnTransaction.customer_email
+        ticket.customerMobileNumber = returnTransaction.customerPhone
+        ticket.customerName = returnTransaction.customer_name
+        activity.customerId = ticket.customerId
+        activity.customerEmailId = returnTransaction.customer_email
+        activity.customerMobileNumber = returnTransaction.customerPhone
+        activity.customerName = returnTransaction.customer_name
+        crmServiceClient.insertTicket(ticket, activity)
+    except:
+        print "Ticket for RTO Refund is not created."
+    return returnTxn.id
+def get_return_transactions_for_customer(statusList, customerMobile, customerEmail, returnTransactionId, customer_id):
+    query = ReturnTransaction.query
+    if statusList is not None and len(statusList) >0:
+        statuses = []
+        for status in statusList:
+            statuses.append(ReturnTransactionStatus._VALUES_TO_NAMES[status])
+        query = query.filter(ReturnTransaction.status.in_(tuple(statuses)))
+    if customer_id:
+        query = query.filter(ReturnTransaction.customer_id == customer_id)
+    if customerMobile:
+        query = query.filter(ReturnTransaction.customerPhone == customerMobile)
+    if customerEmail:
+        query = query.filter(ReturnTransaction.customer_email == customerEmail)
+    return query.all()
+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()
+    if not returnOrders:
+        raise TransactionServiceException(101, "No return order for the transaction")
+    return returnOrders
+def __process_return_order(returnOrder, returnOrderAttrMap):
+    if returnOrder.returnAction:
+        if returnOrder.refundedAt:
+            raise TransactionServiceException(145, "Refund already in Process for this return order")
+        refundReason = returnOrderAttrMap.get('RefundReason')
+        refundType = returnOrderAttrMap.get('RefundType')
+        refundedBy = returnOrderAttrMap.get('RefundedBy')
+        refundAmount = returnOrderAttrMap.get('RefundAmount')
+        order = get_order(returnOrder.orderId)
+        status_transition = {}
+        if order.cod:
+            logging.info("Refunding COD order with status " + str(returnOrder.returnStatus))
+        else:
+            logging.info("Refunding Prepaid order with status " + str(returnOrder.returnStatus))
+        status_transition = {"LOST_IN_TRANSIT" : "LOST_IN_TRANSIT_REFUNDED",
+                     "DOA_CERT_INVALID" : "DOA_INVALID_REFUNDED",
+                     "DOA_CERT_VALID" : "DOA_VALID_REFUNDED",
+                     "DOA_RECEIVED_DAMAGED" : "DOA_REFUNDED_RCVD_DAMAGED",
+                     "DOA_LOST_IN_TRANSIT" : "DOA_REFUNDED_LOST_IN_TRANSIT",
+                     "RET_PRODUCT_UNUSABLE" : "RET_PRODUCT_UNUSABLE_REFUNDED",
+                     "RET_PRODUCT_USABLE" : "RET_PRODUCT_USABLE_REFUNDED",
+                     "RET_RECEIVED_DAMAGED" : "RET_REFUNDED_RCVD_DAMAGED",
+                     "RET_LOST_IN_TRANSIT" : "RET_REFUNDED_LOST_IN_TRANSIT"
+                     }
+        if returnOrder.returnStatus in status_transition.keys():
+            returnOrder.returnStatus = status_transition[returnOrder.returnStatus]
+        elif returnOrder.returnPickupType in [ReturnPickupType.LATER, ReturnPickupType.NOT_REQUIRED]:
+            if returnOrder.returnPickupType == ReturnPickupType.LATER:
+                returnOrder.refundDescription = "Pickup will be processed Later. Refund in Process. It takes 7-10 working days to be in actual credit."
+            else:
+                returnOrder.refundDescription = "No Pickup Required for this item. Refund in Process. It takes 7-10 working days to be in actual credit."
+        else:
+            raise TransactionServiceException(114, "This order can't be refunded")
+        __create_refund(order, returnOrder)
+        returnOrder.refundedAt = datetime.datetime.now()
+        returnOrder.refundedBy = refundedBy
+        returnOrder.refundReason = refundReason
+        returnOrder.refundAmount = refundAmount
+        returnOrder.refundType = refundType
+        session.commit()
+        return True
+    else:
+        alreadyReshipped = False
+        if returnOrder.replacementOrderId:
+            alreadyReshipped = True
+        if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.LOST_IN_TRANSIT]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.LOST_IN_TRANSIT_RESHIPPED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, order.cod)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_INVALID]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_INVALID_RESHIPPED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, True, False)
+            __scan_for_reship_order(returnOrder.orderId, new_order, returnOrder)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_VALID]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_VALID_RESHIPPED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_DAMAGED]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RESHIPPED_RCVD_DAMAGED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_LOST_IN_TRANSIT]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RESHIPPED_LOST_IN_TRANSIT]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_USABLE]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_USABLE_RESHIPPED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_UNUSABLE]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PRODUCT_UNUSABLE_RESHIPPED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_DAMAGED]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RESHIPPED_RCVD_DAMAGED]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_LOST_IN_TRANSIT]:
+            returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RESHIPPED_LOST_IN_TRANSIT]
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+        elif returnOrder.returnPickupType in [ReturnPickupType.LATER, ReturnPickupType.NOT_REQUIRED]:
+            if not alreadyReshipped:
+                order = get_order(returnOrder.orderId)
+                new_order = __clone_order(order, False, False)
+                returnOrder.refundDescription = "Replacement Order has been created."
+        else:
+            return False
+        if not alreadyReshipped:
+            returnOrder.replacementOrderId = new_order.id
+            returnOrder.reshippedAt = datetime.datetime.now()
+            orderQty = returnOrder.returnQuantity
+            if returnOrder.returnPickupType not in [ReturnPickupType.LATER, ReturnPickupType.NOT_REQUIRED]:
+                orderQty = returnOrder.receivedQuantity
+            new_order.lineitems[0].quantity = orderQty
+            new_order.lineitems[0].total_price = new_order.lineitems[0].unit_price * orderQty
+            new_order.lineitems[0].total_weight = new_order.lineitems[0].unit_weight * orderQty
+            new_order.total_amount = new_order.lineitems[0].unit_price * orderQty
+            new_order.total_weight = new_order.lineitems[0].unit_weight * orderQty
+            if returnOrder.shippingType:
+                new_order.transaction = None
+                new_order.promised_shipping_time = None
+                new_order.expected_shipping_time = None
+                new_order.promised_delivery_time = None
+                new_order.expected_delivery_time = None
+            session.commit()
+            return True
+        else:
+            session.commit()
+            return True
+def communicate_pickup_details_to_customer(returnPickupRequest):
+    returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupRequest.id).all()
+    subject = 'Pickup details'
+    filename = "/PickupDetails/" +  str(returnPickupRequest.pickupRequestNo) +".pdf"
+    try:
+        inventory_client = InventoryClient().get_client()
+        warehouse = inventory_client.getWarehouse(returnOrders[0].warehouse_id)
+        logistics_client = LogisticsClient().get_client()
+        provider = logistics_client.getProvider(returnPickupRequest.logisticsProviderId)
+        provider_name = provider.name
+        returnTxn = returnOrders[0].returnTransaction
+        to_addr = returnTxn.customer_email
+        promised_pickup_time = returnPickupRequest.promised_pickup_timestamp.date().strftime("%d-%B-%Y (%A)")
+        customer_address = returnTxn.customer_name +"\n" + returnTxn.customerAddress +"\n"
+        customer_address = customer_address + returnTxn.customerCity + "\n"
+        customer_address = customer_address + returnTxn.customerState + "\n"
+        customer_address = customer_address + "PIN: "+returnTxn.pincode + "\n"
+        customer_address = customer_address + "Phone: "+returnTxn.customerPhone
+        raw_message = '''
+        Dear %(customer_name)s,
+        Would like to inform you that we have instructed %(provider_name)s to pick up the material from the below mentioned address on or before %(date)s. %(provider_name)s pickup request number is %(pickup_request_no)s.'
+        Take a printout of the attachment in this mail which contains the delivery address and paste it on the packed parcel. Kindly keep the parcel ready.
+        Pickup will happen from the below mentioned address:-
+        %(customer_address)s
+        Do let us know in case of any concerns
+        Thanks & Regards
+        %(source_name)s Team
+        '''
+        message = dedent(raw_message) % {'customer_name' : returnTxn.customer_name,
+                                         'order_id' : returnTxn.id,
+                                         'provider_name' : provider_name,
+                                         'date': promised_pickup_time,
+                                         'pickup_request_no' : returnPickupRequest.pickupRequestNo,
+                                         'customer_address' : customer_address,
+                                         'source_name' : source_name}
+        print message
+        __generate_return_transaction_invoice(returnOrders, warehouse, provider, filename)
+        mail(help_user, help_password, [to_addr], subject, message, [get_attachment_part(filename)])
+        session.commit()
+        return True
+    except Exception as e:
+        print sys.exc_info()
+        traceback.print_tb(sys.exc_info()[2])
+        return False
+    finally:
+        if os.path.exists(filename):
+            os.remove(filename)
+def __communicate_customer_for_closed_transaction(returnTransaction):
+    pass
+def change_return_transaction_status(returnTransactionId, new_status, returnOrdersIds=None, returnOrdersAttrMap=None):
+    returnTransaction = ReturnTransaction.get_by(id=returnTransactionId)
+    if returnTransaction is None:
+        raise TransactionServiceException(101, "No Return Transaction Found")
+    if new_status == ReturnTransactionStatus.AUTHORIZED:
+        returnTransaction.authorizedAt = datetime.datetime.now()
+        for returnOrder in returnTransaction.returnOrders:
+            if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_REQUEST_RECEIVED]:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_REQUEST_AUTHORIZED]
+            if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_REQUEST_RECEIVED]:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_REQUEST_AUTHORIZED]
+        returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[new_status]
+    elif new_status == ReturnTransactionStatus.INPROCESS:
+        for returnOrder in returnTransaction.returnOrders:
+            returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.AWAITING_PICKUP]
+            if returnOrder.returnPickupType == ReturnPickupType.NOT_REQUIRED:
+                pass
+            else:
+                if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_REQUEST_AUTHORIZED]:
+                    returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_PICKUP_REQUEST_RAISED]
+                if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_REQUEST_AUTHORIZED]:
+                    returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_PICKUP_REQUEST_RAISED]
+            returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[new_status]
+        returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[new_status]
+    elif new_status == ReturnTransactionStatus.REJECTED:
+        returnTransaction.processedAt = datetime.datetime.now()
+        for returnOrder in returnTransaction.returnOrders:
+            returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.CLOSED]
+            if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_REQUEST_RECEIVED]:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.REJECTED]
+            if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_REQUEST_RECEIVED]:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.REJECTED]
+        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:
+                    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:
+                            ret_Order.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REFUND_IN_PROCESS]
+                        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]
+            else:
+                for ret_Order in returnTransaction.returnOrders:
+                    if ret_Order.returnAction == ReturnAction.REFUND:
+                        ret_Order.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REFUND_IN_PROCESS]
+                    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.CLOSED:
+        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):
+    returnPickupRequest = ReturnPickupRequest()
+    returnPickupRequest.logisticsProviderId = providerId
+    returnPickupRequest.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_REQUESTED]
+    session.commit()
+    for returnOrderId in returnOrderIds:
+        returnOrder = get_return_order_info(returnOrderId)
+        returnOrder.logisticsRequestId = returnPickupRequest.id
+    session.commit()
+    return True
+def update_return_pickup_request(returnPickupRequest):
+    try:
+        returnPickupReq = ReturnPickupRequest.get_by(id=returnPickupRequest.id)
+        if returnPickupRequest.pickupRequestNo:
+            returnPickupReq.pickupRequestNo = returnPickupRequest.pickupRequestNo
+            returnPickupReq.confirmedAt = datetime.datetime.now()
+            returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_CONFIRMED]
+            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)
+            try:
+                communicate_pickup_details_to_customer(returnPickupReq)
+            except:
+                print "Customer Communication Failed for the pickup Information"
+        if returnPickupRequest.pickedUpAt:
+            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]
+        session.commit()
+        return True
+    except:
+        return False
+def receive_return_pickup(returnOrdersMap, req_id):
+    returnPickupReq = ReturnPickupRequest.get_by(id=req_id)
+    returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==req_id).all()
+    if len(returnOrders)!=len(returnOrdersMap.keys()):
+        raise TransactionServiceException(101, "All Returns Orders  Information Missing. Please Fill All Orders Info")
+    for returnOrder in returnOrders:
+        returnOrderDetails = returnOrdersMap.get(returnOrder.id)
+        receiveCondition = ReceivedReturnType._NAMES_TO_VALUES[returnOrderDetails.get('ReceiveCondition')]
+        quantity = int(returnOrderDetails.get('Quantity'))
+        if returnOrder.returnStatus in [OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_PICKUP_CONFIRMED], OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_RETURN_IN_TRANSIT]]:
+            if receiveCondition == ReceivedReturnType.PRESTINE:
+                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_RECEIVED_PRESTINE]
+            elif receiveCondition == ReceivedReturnType.DAMAGED:
+                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.DOA_RECEIVED_DAMAGED]
+            elif receiveCondition == ReceivedReturnType.LOST_IN_TRANSIT:
+                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[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]]:
+            if receiveCondition == ReceivedReturnType.PRESTINE:
+                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_RECEIVED_PRESTINE]
+            elif receiveCondition == ReceivedReturnType.DAMAGED:
+                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_RECEIVED_DAMAGED]
+            elif receiveCondition == ReceivedReturnType.LOST_IN_TRANSIT:
+                returnOrder.returnStatus = OrderStatus._NAMES_TO_VALUES[OrderStatus.RET_LOST_IN_TRANSIT]
+            returnOrder.receivedAt = datetime.datetime.now()
+            returnOrder.receivedQuantity = quantity
+        else:
+            return False
+    scanMap = {
+            "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
+        }
+    inventoryClient = InventoryClient().get_client()
+    warehouse = inventoryClient.getWarehouse(returnOrders[0].warehouse_id)
+    warehouseClient = WarehouseClient().get_client()
+    for returnOrder in returnOrders:
+        warehouse = None
+        serialNumbers = []
+        if returnOrderDetails.has_key('SerialNumbers'):
+            serialNumbers = returnOrderDetails.get('SerialNumbers').split(',')
+        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 scanMap.has_key(returnOrder.returnStatus):
+                scanType = scanMap[returnOrder.returnStatus]
+                lineitem = returnOrder.lineitem
+                return_qty = lineitem.returnQty - returnOrder.returnQuantity + quantity
+                lineitem.returnQty = lineitem.returnQty - returnOrder.returnQuantity + quantity
+                order = get_order(returnOrder.orderId)
+                if return_qty < order.lineitems[0].quantity:
+                    order.status = OrderStatus.PARTIAL_RETURN
+                if return_qty == order.lineitems[0].quantity:
+                    order.status = OrderStatus.COMPLETE_RETURN
+                if warehouse.billingType == BillingType.OURS or scanType != ScanType.SALE_RET:
+                    if lineitem.serial_number is not None:
+                        if serialNumbers is None or len(serialNumbers)==0 or len(serialNumbers)<quantity:
+                            return False
+                        else:
+                            for serialNumber in serialNumbers:
+                                try:
+                                    warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
+                                except:
+                                    warehouseClient = WarehouseClient().get_client()
+                                    warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
+                    else:
+                        try:
+                            warehouseClient.scanForOrder(None, scanType, quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
+                        except:
+                            warehouseClient = WarehouseClient().get_client()
+                            warehouseClient.scanForOrder(None, scanType, quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
+                if warehouse.billingType == BillingType.OURS_EXTERNAL and scanType == ScanType.SALE_RET:
+                    try:
+                        warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
+                    except:
+                        warehouseClient = WarehouseClient().get_client()
+                        warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
+                if scanFreebie:
+                    try:
+                        warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
+                    except:
+                        warehouseClient = WarehouseClient().get_client()
+                        warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
+    returnPickupReq.pickupStatus = ReturnTxnPickupStatus._VALUES_TO_NAMES[ReturnTxnPickupStatus.PICKUP_RECEIVED]
+    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")
+    for returnOrder in returnOrders:
+        if returnOrder.returnStatus != OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_PRESTINE] and returnOrder.returnStatus != OrderStatus._VALUES_TO_NAMES[OrderStatus.RET_RECEIVED_PRESTINE]:
+            return False
+    for returnOrder in returnOrders:
+        isValid = returnOrdersMap.get(returnOrder.id)
+        if returnOrder.returnStatus == OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_RECEIVED_PRESTINE]:
+            if isValid:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_VALID]
+            else:
+                returnOrder.returnStatus = OrderStatus._VALUES_TO_NAMES[OrderStatus.DOA_CERT_INVALID]
+        else:
+            if isValid:
+                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 process_return_pickup(returnPickupId, returnOrdersMap):
+    returnOrders = ReturnOrderInfo.query.filter(ReturnOrderInfo.logisticsRequestId==returnPickupId).all()
+    returnTxnIdOrdersMap = {}
+    if len(returnOrders)!=len(returnOrdersMap.keys()):
+        raise TransactionServiceException(101, "All Returns Orders Information Missing. Please Fill All Orders Info")
+    for returnOrder in returnOrders:
+        if returnTxnIdOrdersMap.has_key(returnOrder.returnTransaction.id):
+            ordersList = returnTxnIdOrdersMap.get(returnOrder.returnTransaction.id)
+            ordersList.append(returnOrder.id)
+            returnTxnIdOrdersMap[returnOrder.returnTransaction.id] = ordersList
+        else:
+            ordersList = []
+            ordersList.append(returnOrder.id)
+            returnTxnIdOrdersMap[returnOrder.returnTransaction.id] = ordersList
+    for returnTransactionId, returnOrdersIds in returnTxnIdOrdersMap.items():
+        change_return_transaction_status(returnTransactionId, ReturnTransactionStatus.PROCESSED, returnOrdersIds, returnOrdersMap)
+    session.commit()
+    return True
+def mark_return_transaction_complete(returnTransactionId):
+    returnTransaction = get_return_transaction(returnTransactionId)
+    if returnTransaction.status == ReturnTransactionStatus._VALUES_TO_NAMES[ReturnTransactionStatus.COMPLETED]:
+        raise TransactionServiceException(101, "Transaction Already completed")
+    returnString = ''
+    for returnOrder in returnTransaction.returnOrders:
+        if returnOrder.processedAt is None:
+            returnString = returnString + str(returnOrder.id)+":"+str(returnOrder.lineitem)+"|"
+    if len(returnString) >0 :
+        raise TransactionServiceException(140, "Unprocessed orders are: "+returnString)
+    returnTransaction.status = ReturnTransactionStatus._VALUES_TO_NAMES[ReturnTransactionStatus.COMPLETED]
+    session.commit()
+    return True
+def refund_return_transaction_payment(returnOrdersMap, returnTransactionId):
+    for returnOrderId, returnOrderAttrMap in returnOrdersMap.items():
+        returnOrder = get_return_order_info(returnOrderId)
+        if returnOrder.returnAction:
+            returnOrder.processedAt = datetime.datetime.now()
+            returnOrder.refundDescription = returnOrder.refundDescription + returnOrderAttrMap.get("RefundInfo")
+            returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REFUND_DONE]
+        else:
+            returnOrder.processedAt = datetime.datetime.now()
+            returnOrder.refundDescription = str(returnOrder.replacementOrderId) + " has been delivered now"
+            returnOrder.returnTxnResolutionStatus = ReturnTxnResolutionStatus._VALUES_TO_NAMES[ReturnTxnResolutionStatus.REPLACEMENT_DONE]
+    session.commit()
 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 19688 → 19691