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_all_orders, change_order_status, get_alerts, set_alert, add_billing_details,\
    mark_orders_as_manifested, close_session, accept_order, bill_order
from shop2020.model.v1.order.impl.Convertors import to_t_transaction,\
    to_t_lineitem, to_t_alert, to_t_order, to_t_lineitem
from shop2020.thriftpy.model.v1.order.ttypes import Transaction, OrderStatus,\
    LineItem, Order
from shop2020.utils.Utils import to_py_date, get_fdate_tdate

class OrderServiceHandler:
    
    def __init__(self):
        """
        Constructor
        """
        DataService.initialize()
        
    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):
        """
        Parameters:
         - transactionId
         - status
         - description
        """
        try:
            return change_transaction_status(transactionId, status, description)
        finally:
            close_session()
            
    def getOrdersForTransaction(self, transactionId):
        """
        Parameters:
         - transactionId
        """
        try:
            orders = get_orders_for_transaction(transactionId)
            return [to_t_order(order) for order in orders]    
        finally:
            close_session()
            
    def getAllOrders(self, status, 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(status, current_from_date, current_to_date, warehouse_id)
            return [to_t_order(order) for order in orders]
        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 acceptOrder(self, orderId):
        """
        Parameters:
         - orderId
        """
        try:
            return accept_order(self, orderId)
        finally:
            close_session()
    
    def billOrder(self, orderId):
        """
        Parameters:
         - orderId
        """
        try:
            return bill_order(self, orderId)
        finally:
            close_session()
            
    def getOrdersForCustomer(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)
            
            orders = get_orders_for_customer(customerId, current_from_date, current_to_date, status)
            return [to_t_order(order) for order in orders]
        finally:
            close_session()
            
    def getOrder(self, id):
        """
        Parameters:
         - id
        """
        try:
            return to_t_order(get_order(id))
        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, jacket_number, billed_by):
        """
        Parameters:
         - orderId
         - invoice_number
         - billed_by
        """
        try:
            return add_billing_details(orderId, invoice_number, jacket_number, billed_by)
        finally:
            close_session()
            
    def markOrdersAsManifested(self, warehouseId, providerId):
        """
        Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
        
        Parameters:
         - warehouseId
         - providerId
        """
        try:
            return mark_orders_as_manifested(warehouseId, providerId)
        finally:
            close_session()
            
    def getAlerts(self, orderId, valid):
        """
        Parameters:
         - orderId
         - valid
        """
        try:
            alerts = get_alerts(orderId, valid)
            
            t_alerts = []
            
            for alert in alerts:
                t_alerts.append(to_t_alert(alert)) 
            
            return t_alerts
        finally:
            close_session()
            
    def setAlert(self, orderId, unset, type, comment):
        """
        Parameters:
         - orderId
         - unset
         - type
         - comment
        """
        try:
            set_alert(orderId, unset, type, comment)
        finally:
            close_session()
            
    def closeSession(self, ):
        close_session()
    
    
    
    '''
if __name__ == "__main__":
    order = OrderServiceHandler()
    t = order.getTransaction(4)
    print t
    
    
    these methods commented right now. may be used later
    def getAllTransactions(self, status, from_date, to_date, warehouse_id):
        """
        Parameters:
         - status
         - from_date
         - to_date
        """
        current_status, current_from_date, current_to_date = get_status_fdate_tdate(status, from_date, to_date)
        
        transactions = get_all_transactions(current_status, current_from_date, current_to_date, warehouse_id)
        t_transaction = []
        for transaction in transactions:
            t_transaction.append(to_t_transaction(transaction))
        return t_transaction

    def getTransactionsForShipmentStatus(self, status, from_date, to_date):
        """
        Parameters:
         - status
         - from_date
         - to_date
        """
        current_status, current_from_date, current_to_date = get_status_fdate_tdate(status, from_date, to_date)
            
        transactions = get_transactions_for_shipment_status(current_status, current_from_date, current_to_date)
        t_transaction = []
        for transaction in transactions:
            t_transaction.append(to_t_transaction(transaction))
        return t_transaction

    def getTransactionsForCustomerAndShipmentStatus(self, customerId, from_date, to_date, status):
        """
        Parameters:
         - customerId
         - from_date
         - to_date
         - status
        """
        current_status, current_from_date, current_to_date = get_status_fdate_tdate(status, from_date, to_date)
      
        transactions = get_transactions_for_customer_shipment(customerId, current_from_date, current_to_date, current_status)
        t_transaction = []
        for transaction in transactions:
            t_transaction.append(to_t_transaction(transaction))
        return t_transaction

    def getOrderInfo(self, transactionId):
        """
            Get and set individual objects in it
        *
        
        Parameters:
         - transactionId
        """
        lineitems = get_line_items(transactionId)
        order_info = OrderInfo()
        order_info.lineitems = []
        for lineitem in lineitems:
            order_info.lineitems.append(to_t_lineitem(lineitem))
            order_info.id = lineitem.transaction.id
        
        return order_info
    
    def getShippingInfo(self, transactionId):
        """
        Parameters:
         - transactionId
        """
        shipments = get_shipments(transactionId)
        shipment_info = ShipmentInfo()
        shipment_info.shipments = []
        for shipment in shipments:
            shipment_info.shipments.append(to_t_shipment(shipment))
            shipment_info.id = shipment.id
        return shipment_info
    def getBillingInfo(self, transactionId):
        """
        Parameters:
         - transactionId
        """
        billings = get_billings(transactionId)
        billing_info = BillingInfo()
        billing_info.billings = []
        if billings:
            for billing in billings:
                billing_info.billings.append(to_t_billing(billing))
                billing_info.id = billing.line_item.transaction.id
        return billing_info
    
    def addBilling(self, transactionId, billing):
        """
        Parameters:
         - tranactionId
         - billing
        """
        return set_billing(transactionId, billing)
    
    def setShippingTracker(self, transactionId, shippingId, trackingId, airwayBillNo, provider):
        """
        Parameters:
         - transactionId
         - shippingId
         - trackingId
         - airwayBillNo
         - provider
        """
        return set_shipping_tracker_info(transactionId, shippingId, trackingId, airwayBillNo, provider)
    
    def setShippingDate(self, transactionId, shippingId, timestamp):
        """
        Parameters:
         - transactionId
         - shippingId
         - timestamp
        """
        return set_shipping_date(transactionId, shippingId, to_py_date(timestamp))
    
    def setDeliveryDate(self, transactionId, shippingid, timestamp):
        """
        Parameters:
         - transactionId
         - shippingid
         - timestamp
        """
        return set_delivery_date(transactionId, shippingid, timestamp)

    def getAlerts(self, transactionId, valid):
        """
        Parameters:
         - transactionId
         - valid
        """
        alerts = get_alerts(transactionId, valid)
        
        t_alerts = []
        
        for alert in alerts:
            t_alerts.append(to_t_alert(alert)) 
        
        return t_alerts

    def setAlert(self, transactionId, unset, type, comment):
        """
        Parameters:
         - transactionId
         - unset
         - type
         - comment
        """
        set_alert(transactionId, unset, type, comment)

    def getExtraInfo(self, transaction_id):
        """
        Parameters:
         - transaction_id
        """
        extra_info = get_extra_info(transaction_id)
        
        return to_t_extra_item_info(extra_info, transaction_id)
        

    def setExtraInfo(self, transaction_id, sku_id, model, colour, vendor):
        """
        Parameters:
         - transaction_id
         - sku_id
         - model
         - colour
         - vendor
        """
        set_extra_info(transaction_id, sku_id, model, vendor, colour)

    '''