Subversion Repositories SmartDukaan

'''

Created on 29-Mar-2010

@author: ashish

'''

from shop2020.model.v1.order.impl import DataService

from shop2020.model.v1.order.impl.DataAccessors import create_transaction,\

    create_order, get_new_transaction, get_transactions_for_customer, get_transaction_status,\

    get_line_items_for_order, get_transaction, get_transactions_for_shopping_cart_id,\

    change_transaction_status, get_orders_for_customer,get_orders_for_transaction, get_order,\

    get_returnable_orders_for_customer, get_cancellable_orders_for_customer, get_orders_by_billing_date,\

    get_all_orders, change_order_status, get_alerts, add_alert, add_billing_details,\

    close_session, accept_order, mark_orders_as_picked_up,\

    mark_orders_as_delivered, mark_orders_as_rto,\

    order_outofstock, batch_orders, update_non_delivery_reason, enqueue_transaction_info_email,\

    get_undelivered_orders, get_order_for_customer, get_valid_order_count,\

    get_cust_count_with_successful_txn, get_valid_orders_amount_range,\

    get_valid_orders, toggle_doa_flag, request_pickup_number, authorize_pickup,\

    receive_return, validate_doa, reship_order, refund_order, get_return_orders,\

    process_return, get_return_order, mark_doas_as_picked_up, verify_order, is_alive, get_orders_by_shipping_date,\

    update_weight, change_warehouse, change_product, add_delay_reason,\

    reconcile_cod_collection, get_transactions_requiring_extra_processing,\

    mark_transaction_as_processed, get_item_wise_risky_orders_count, accept_order_for_item, \

    get_orders_in_batch, get_order_count, get_ebs_settlement_summaries, mark_order_cancellation_request_received,\

    mark_order_cancellation_request_denied, refund_transaction, mark_order_cancellation_request_confirmed,\

    mark_transaction_as_payment_flag_removed, accept_orders_for_item_id,\

    mark_orders_as_po_raised, mark_orders_as_reversal_initiated, mark_orders_as_not_available, update_shipment_address,\

    mark_orders_as_timeout, get_order_for_awb, mark_orders_as_shipped_from_warehouse, mark_alerts_as_seen, \

    mark_order_doa_request_received, mark_order_doa_request_authorized,\

    mark_order_return_request_received, mark_order_return_request_authorized, add_invoice_number, get_reshipped_order_ids, \

    validate_return_product, get_orders_for_provider_for_status, save_ebs_settlement_summary, get_ebs_settlement_date, \

    save_payment_settlements, mark_ebs_settlement_uploaded, get_billed_orders_for_vendor, get_settlement_for_Prepaid, \

    get_settlements_by_date, get_slipped_sipping_date_orders, mark_order_as_lost_in_transit,\

    get_cancelled_orders, mark_order_as_delivered, mark_return_orders_as_picked_up, update_orders_as_PORaised,\

    get_order_distribution_by_status, get_orders_not_met_expected_delivery_date,\

    mark_orders_as_local_connected, mark_orders_as_destinationCityReached,\

    mark_orders_as_firstDeliveryAttempted, get_non_delivered_orders_by_courier, get_orders_not_local_connected,\

    get_doas_not_picked_up, get_return_orders_not_picked_up, get_orders_not_picked_up, get_rto_orders, get_order_list,\

    get_order_ids_for_status, update_orders_as_paid_to_vendor, update_COD_agent,\

    get_refunded_orders_marked_paid, get_settlement_for_Cod, get_order_list_for_vendor, update_order_only_as_paid_to_vendor,\

    get_all_verification_agents, get_all_attributes_for_order_id, set_order_attribute_for_transaction, get_billed_orders, get_all_return_orders,\

    mark_order_as_received_at_store, get_receive_pending_orders,\

    get_received_at_store_orders, mark_orders_as_returned_from_store, set_order_attributes

from shop2020.model.v1.order.impl.Convertors import to_t_transaction,\

    to_t_alert, to_t_order, to_t_lineitem, to_t_payment_settlement, to_t_verification_agent, to_t_attribute

from shop2020.thriftpy.model.v1.order.ttypes import Transaction, OrderStatus,\

    LineItem, Order, TransactionServiceException

from shop2020.utils.Utils import to_py_date, get_fdate_tdate, to_java_date

class OrderServiceHandler:

    def __init__(self, dbname='transaction', db_hostname='localhost'):

        """

        Constructor

        """

        DataService.initialize(dbname, db_hostname)

    def createTransaction(self, transaction):

        """

        Parameters:

         - transaction

        """

        try:

            return create_transaction(transaction)

        finally:

            close_session()

    def getTransaction(self, id):

        """

            Get transaction methods.

        Parameters:

         - id

        """

        try:

            transaction = get_transaction(id)

            return to_t_transaction(transaction)

        finally:

            close_session()

    def getTransactionsForCustomer(self, customerId, from_date, to_date, status):

        """

        Parameters:

         - customerId

         - from_date

         - to_date

         - status

        """

        try:

            current_from_date, current_to_date = get_fdate_tdate(from_date, to_date)

            transactions = get_transactions_for_customer(customerId, current_from_date, current_to_date, status)

            t_transaction = []

            for transaction in transactions:

                t_transaction.append(to_t_transaction(transaction))

            return t_transaction

        finally:

            close_session()

    def getTransactionsForShoppingCartId(self, shoppingCartId):

        """

        Parameters:

            - shoppingCartId

        """

        try:

            transactions = get_transactions_for_shopping_cart_id(shoppingCartId)

            t_transaction = []

            for transaction in transactions:

                t_transaction.append(to_t_transaction(transaction))

            return t_transaction

        finally:

            close_session()

    def getTransactionStatus(self, transactionId):

        """

        Parameters:

         - transactionId

        """

        try:

            return get_transaction_status(transactionId)

        finally:

            close_session()

    def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):

        """

        Parameters:

         - transactionId

         - status

         - description

         - selfPickup

        """

        try:

            return change_transaction_status(transactionId, status, description, pickUp, orderType)

        finally:

            close_session()

    def getOrdersForTransaction(self, transactionId, customerId):

        """

        Returns list of orders for given transaction Id. Also filters based on customer Id so that

        only user who owns the transaction can view its order details.

        Parameters:

         - transactionId

         - customerId

        """

        try:

            orders = get_orders_for_transaction(transactionId, customerId)

            return [to_t_order(order) for order in orders]    

        finally:

            close_session()

    def getAllOrders(self, statuses, from_date, to_date, warehouse_id):

        """

        Parameters:

         - status

         - from_date

         - to_date

         - warehouse_id

        """

        try:

            current_from_date, current_to_date = get_fdate_tdate(from_date, to_date)        

            orders = get_all_orders(statuses, current_from_date, current_to_date, warehouse_id)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):

        """

        Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.

        Pass the status as null and the limit as 0 to ignore them.

        Parameters:

         - statuses

         - offset

         - limit

         - warehouse_id

        """

        try:

            orders = get_orders_in_batch(statuses, offset, limit, warehouse_id)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getOrderCount(self, statuses, warehouseId):

        """

        Returns the count of orders with the given statuses assigned to the given warehouse.

        Parameters:

         - statuses

         - warehouseId

        """

        try:

            return get_order_count(statuses, warehouseId)

        finally:

            close_session()

    def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):

        """

        Parameters:

         - status

         - start_billing_date

         - end_billing_date

         - warehouse_id

        """

        try:

            current_start_billing_date, current_end_billing_date = get_fdate_tdate(start_billing_date, end_billing_date)

            orders = get_orders_by_billing_date(status, current_start_billing_date, current_end_billing_date, warehouse_id)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):

        """

        Returns orders for a particular provider and warehouse which were shipped between the given dates.

        Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.

        Pass providerId and warehouseId as -1 to ignore both these parameters.

        Parameters:

         - fromShippingDate

         - toShippingDate

         - providerId

         - warehouseId

         - cod

        """

        try:

            from_shipping_date, to_shipping_date = get_fdate_tdate(fromShippingDate, toShippingDate)

            orders = get_orders_by_shipping_date(from_shipping_date, to_shipping_date, providerId, warehouseId, cod)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getReturnableOrdersForCustomer(self, customerId, limit = None):

        """

        Parameters:

         - customerId

         - limit

        """

        try:

            return get_returnable_orders_for_customer(customerId, limit)

        finally:

            close_session()

    def getCancellableOrdersForCustomer(self, customerId, limit = None):

        """

        Parameters:

         - customerId

         - limit

        """

        try:

            return get_cancellable_orders_for_customer(customerId, limit)

        finally:

            close_session()

    def changeOrderStatus(self, orderId, status, description):

        """

        Parameters:

         - orderId

         - status

         - description

         - 

        """

        try:

            return change_order_status(self, orderId, status, description)

        finally:

            close_session()

    def verifyOrder(self, orderId):

        """

        Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified

        timestamp. It is intended to be used for COD orders but can be harmlessly

        used for all other orders as well.

        Throws an exception if no such order exists.

        Parameters:

         - orderId

        """

        try:

            return verify_order(self, orderId)

        finally:

            close_session()

    def acceptOrder(self, orderId):

        """

        Marks the given order as ACCEPTED and updates the accepted timestamp. If the

        given order is not a COD order, it also captures the payment if the same has

        not been captured.

        Throws an exception if no such order exists.

        Parameters:

         - orderId

        """

        try:

            return accept_order(orderId)

        finally:

            close_session()

    def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):

        """

        Returns list of orders for the given customer created between the given dates and having the given statuses.

        Pass and empty list to ignore filtering on statuses.

        Parameters:

         - customerId

         - from_date

         - to_date

         - statuses

        """

        try:

            current_from_date, current_to_date = get_fdate_tdate(from_date, to_date)

            orders = get_orders_for_customer(customerId, current_from_date, current_to_date, statuses)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getOrderForCustomer(self, orderId, customerId):

        """

        Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.

        Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.

        Parameters:

         - customerId

         - orderId

        """

        try:

            return to_t_order(get_order_for_customer(orderId, customerId))

        finally:

            close_session()

    def getOrder(self, id):

        """

        Parameters:

         - id

        """

        try:

            return to_t_order(get_order(id))

        finally:

            close_session()

    def getOrderList(self, order_ids):

        """

        Parameters:

         - order_ids

        """

        try:

            orders = get_order_list(order_ids)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getOrderListForVendor(self, order_ids, vendorId):

        """

        Parameters:

         - order_ids

         - vendorId

        """

        try:

            orders = get_order_list_for_vendor(order_ids, vendorId)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getLineItemsForOrder(self, orderId):

        """

        Parameters:

         - orderId

        """

        try:

            lineitems = get_line_items_for_order(orderId)

            t_lineitems = []

            for lineitem in lineitems:

                t_lineitems.append(to_t_lineitem(lineitem))

            return t_lineitems

        finally:

            close_session()

    def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billedBy, jacketNumber, billingType, vendorId, authorize):

        """

        Adds jacket number and serial no. to the order. Doesn't update the serial no. if a -1 is supplied.

        Also marks the order as billed and sets the billing timestamp.

        Return false if it doesn't find the order with the given ID.

        Parameters:

         - orderId

         - jacketNumber

         - serialNumber

         - itemNumber

         - billedBy

        """

        try:

            return add_billing_details(orderId, invoice_number, serialNumber, itemNumber, billedBy, jacketNumber, billingType, vendorId, authorize)

        finally:

            close_session()

    def addInvoiceNumber(self, orderId, invoiceNumber, color):

        """

        Add the invoice number to the order.

        Parameters:

         - orderId

         - invoice_number

        """

        try:

            add_invoice_number(orderId, invoiceNumber, color)

        finally:

            close_session()

    def batchOrders(self, warehouseId):

        """

        Create a batch of all the pending orders for the given warehouse.

        The returned list is orderd by created_timestamp.

        If there are no pending orders, an empty list is returned.

        Parameters:

         - warehouseId

        """

        try:

            pending_orders = batch_orders(warehouseId)

            return [to_t_order(order) for order in pending_orders]

        finally:

            close_session()

    def markOrderAsOutOfStock(self, orderId):

        """

        Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.

        Parameters:

         - orderId

        """

        try:

            return order_outofstock(orderId)

        finally:

            close_session()

    def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):

        """

        Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the

        given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.

        Parameters:

         - warehouseId

         - providerId

         - cod

        """

        try:

            return mark_orders_as_shipped_from_warehouse(warehouseId, providerId, cod, orderIds)

        finally:

            close_session()

    def markOrdersAsReturnedFromStore(self, providerId, orderIds):

        """

        Parameters:

         - providerId

         - orderIds

        """

        try:

            return mark_orders_as_returned_from_store(providerId, orderIds)

        finally:

            close_session()

    def setOrderAttributes(self, orderId, attributes):

        """

        sets attributes for an order

        Parameters:

         - orderId

         - attributes

        """

        try:

            return set_order_attributes(orderId, attributes)

        finally:

            close_session()

    def markOrdersAsPickedUp(self, providerId, pickupDetails):

        """

        Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.

        Raises an exception if we encounter report for an AWB number that we did not ship.

        Parameters:

         - providerId

         - pickupDetails

        """

        try:

            mark_orders_as_picked_up(providerId, pickupDetails)

        finally:

            close_session()

    def getOrdersNotPickedUp(self, providerId):

        """

        Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.

        Parameters:

         - providerId

        """

        try:

            orders_not_picked_up = get_orders_not_picked_up(providerId)

            return [to_t_order(order) for order in orders_not_picked_up]

        finally:

            close_session()

    def markOrdersAsDelivered(self, providerId, deliveredOrders):

        """

        Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and

        the name of the receiver.

        Raises an exception if we encounter report for an AWB number that we did not ship.

        Parameters:

         - providerId

         - deliveredOrders

        """

        try:

            mark_orders_as_delivered(providerId, deliveredOrders)

        finally:

            close_session()

    def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):

        """

        Attributes:

         - orderId

         - deliveryTimestamp

         - receiver

        """

        try:

            mark_order_as_delivered(orderId, to_py_date(deliveryTimestamp), receiver)

        finally:

            close_session()

    def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):

        """

        Attributes:

         - orderId

         - deliveryTimestamp

        """

        try:

            mark_order_as_received_at_store(orderId, to_py_date(deliveryTimestamp))

        finally:

            close_session()

    def getReceivePendingOrders(self, storeId):

        """

        Attributes:

         - storeId

        """

        try:

            orders = get_receive_pending_orders(storeId)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def getReceivedAtStoreOrders(self, storeId):

        """

        Attributes:

         - storeId

        """

        try:

            orders = get_received_at_store_orders(storeId)

            return [to_t_order(order) for order in orders]

        finally:

            close_session()

    def markAsRTOrders(self, providerId, returnedOrders):

        """

        Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.

        Raises an exception if we encounter report for an AWB number that we did not ship.

        Parameters:

         - providerId

         - returnedOrders

        """

        try:

            mark_orders_as_rto(providerId, returnedOrders)

        finally:

            close_session()

    def getRTOrders(self, providerId):

        """

        Returns a list of orders that were returned by courier.

        Parameters:

         - providerId

        """

        try:

            rto_orders = get_rto_orders(providerId)

            return [to_t_order(order) for order in rto_orders]

        finally:

            close_session()

    def updateNonDeliveryReason(self, providerId, undeliveredOrders):

        """

        Update the status description of orders whose AWB numbers are keys of the Map.

        Parameters:

         - providerId

         - undelivered_orders

        """

        try:

            update_non_delivery_reason(providerId, undeliveredOrders)

        finally:

            close_session()

    def getNonDeliveredOrdersbyCourier(self, providerId):

        """

        Returns a list of orders that were picked up or shipped four days ago but did not get delivered.

        Parameters:

         - providerId

        """

        try:

            orders_not_delivered = get_non_delivered_orders_by_courier(providerId)

            return [to_t_order(order) for order in orders_not_delivered]

        finally:

            close_session()

    def markOrdersAsLocalConnected(self, providerId, local_connected_orders):

        """

        Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.

        Parameters:

         - providerId

         - local_connected_orders

        """

        try:

            mark_orders_as_local_connected(providerId, local_connected_orders)

        finally:

            close_session()

    def getOrdersNotLocalConnected(self, providerId):

        """

        Returns a list of orders that were picked up or shipped but pending local connection.

        Parameters:

         - providerId

        """

        try:

            orders_pending_local_connection = get_orders_not_local_connected(providerId)

            return [to_t_order(order) for order in orders_pending_local_connection]

        finally:

            close_session()

    def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):

        """

        Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.

        Parameters:

         - providerId

         - destination_city_reached_orders

        """

        try:

            mark_orders_as_destinationCityReached(providerId, destination_city_reached_orders)

        finally:

            close_session()

    def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):

        """

        Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.

        Parameters:

         - providerId

         - first_atdl_orders

        """

        try:

            mark_orders_as_firstDeliveryAttempted(providerId, first_atdl_orders)

        finally:

            close_session()

    def getUndeliveredOrdersExpectedDeliveryDateNotMet(self):

        """

        Returns the list of orders whose expected delivery date has passed but have not been

        delivered yet.

        Returns an empty list if no such orders exist.

        """

        try:

            orders_not_delivered = get_orders_not_met_expected_delivery_date()

            return [to_t_order(order) for order in orders_not_delivered]

        finally:

            close_session()

    def getUndeliveredOrders(self, providerId, warehouseId):

        """

        Returns the list of orders whose delivery time has passed but have not been

        delivered yet for the given provider and warehouse. To get a complete list of

        undelivered orders, pass them as -1.

        Returns an empty list if no such orders exist.

        Parameters:

         - providerId

         - warehouseId

        """

        try:

            undelivered_orders = get_undelivered_orders(providerId, warehouseId)

            return [to_t_order(order) for order in undelivered_orders]

        finally:

            close_session()

    def enqueueTransactionInfoEmail(self, transactionId):

        """

        Save the email containing order details to be sent to customer later by batch job

        Parameters:

         - transactionId

        """

        try:

            return enqueue_transaction_info_email(transactionId)

        finally:

            close_session()

    def getAlerts(self, type, warehouseId, status, timestamp):

        """

        Parameters:

         - type

         - warehouseId

         - status

         - timestamp

        """

        try:

            alerts = get_alerts(type, warehouseId, status, timestamp)

            t_alerts = []

            for alert in alerts:

                t_alerts.append(to_t_alert(alert)) 

            return t_alerts

        finally:

            close_session()

    def addAlert(self, type, warehouseId, description):

        """

        Parameters:

         - type

         - description

         - warehouseId

        """

        try:

            add_alert(type, warehouseId, description)

        finally:

            close_session()

    def markAlertsAsSeen(self, warehouseId):

        """

        Parameters:

         - warehouseId

        """

        try:

            mark_alerts_as_seen(warehouseId)

        finally:

            close_session()

        pass

    def getValidOrderCount(self, ):

        """

        Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)

        """

        try:

            return get_valid_order_count()

        finally:

            close_session()

    def getNoOfCustomersWithSuccessfulTransaction(self, ):

        """

        Returns the number of distinct customers who have done successful transactions

        """

        try:

            return get_cust_count_with_successful_txn()

        finally:

            close_session()

    def getValidOrdersAmountRange(self, ):

        """

        Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)

        List contains two values, first minimum amount and second maximum amount.

        """

        try:

            return get_valid_orders_amount_range()

        finally:

            close_session()

    def getValidOrders(self, limit):

        """

        Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.

        If limit is passed as 0, then all valid Orders are returned.

        Parameters:

         - limit

        """

        try:

            return [to_t_order(order) for order in get_valid_orders(limit)]

        finally:

            close_session()

    def toggleDOAFlag(self, orderId):

        """

        Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.

        Returns the final flag status.

        Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.

        Parameters:

         - orderId

        """

        try:

            return toggle_doa_flag(orderId)

        finally:

            close_session()

    def markOrderDoaRequestReceived(self, orderId):

        """

        Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED

        Parameters:

         - orderId

        """

        try:

            return mark_order_doa_request_received(orderId)

        finally:

            close_session()

    def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):

        """

        CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED

        to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.

        Parameters:

         - orderId

         - isAuthorized

        """

        try:

            return mark_order_doa_request_authorized(orderId, isAuthorized)

        finally:

            close_session()

    def markOrderReturnRequestReceived(self, orderId):

        """

        Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED

        Parameters:

         - orderId

        """

        try:

            return mark_order_return_request_received(orderId)

        finally:

            close_session()

    def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):

        """

        CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED

        to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.

        Parameters:

         - orderId

         - isAuthorized

        """

        try:

            return mark_order_return_request_authorized(orderId, isAuthorized)

        finally:

            close_session()

    def requestPickupNumber(self, orderId, providerId):

        """

        Sends out an email to the account manager of the original courier provider used to ship the order.

        If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.

        If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.

        For any other status, it returns false.

        Throws an exception if the order with the given id couldn't be found.

        Parameters:

         - orderId

        """

        try:

            return request_pickup_number(orderId, providerId)

        finally:

            close_session()

    def authorizePickup(self, orderId, pickupNumber, providerId):

        """

        If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following

            1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.

            2. Changes order status to be DOA_PICKUP_AUTHORIZED.

            3. Returns true

        If the order is any other status, it returns false.

        Throws an exception if the order with the given id couldn't be found.

        Parameters:

         - orderId

         - pickupNumber

        """

        try:

            return authorize_pickup(orderId, pickupNumber, providerId)

        finally:

            close_session()    

    def markDoasAsPickedUp(self, providerId, pickupDetails):

        """

        Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.

        Parameters:

         - providerId

         - pickupDetails

        """

        try:

            mark_doas_as_picked_up(providerId, pickupDetails)

        finally:

            close_session()

    def getDoasNotPickedUp(self, providerId):

        """

        Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.

        Parameters:

         - providerId

        """

        try:

            orders_not_picked_up = get_doas_not_picked_up(providerId)

            return [to_t_order(order) for order in orders_not_picked_up]

        finally:

            close_session()

    def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):

        """

        Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.

        Parameters:

         - providerId

         - pickupDetails

        """

        try:

            mark_return_orders_as_picked_up(providerId, pickupDetails)

        finally:

            close_session()

    def getReturnOrdersNotPickedUp(self, providerId):

        """

        Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.

        Parameters:

         - providerId

        """

        try:

            orders_not_picked_up = get_return_orders_not_picked_up(providerId)

            return [to_t_order(order) for order in orders_not_picked_up]

        finally:

            close_session()

    def receiveReturn(self, orderId, receiveCondition):

        """

        If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.

        If the order is in any other state, it returns false.

        Throws an exception if the order with the given id couldn't be found.

        Parameters:

         - orderId

        """

        try:

            return receive_return(orderId, receiveCondition)

        finally:

            close_session()

    def validateDoa(self, orderId, isValid):

        """

        Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,

        the order state is changed to DOA_CERT_PENDING.

        If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.

        If the order is in any other state, it returns false.

        Throws an exception if the order with the given id couldn't be found.