Subversion Repositories SmartDukaan

#!/usr/bin/python

import optparse
import time
import datetime
import sys
from elixir import session

if __name__ == '__main__' and __package__ is None:
    import os
    sys.path.insert(0, os.getcwd())

from shop2020.clients.CatalogClient import CatalogClient
from shop2020.thriftpy.model.v1.order.ttypes import OrderStatus,\
    TransactionServiceException
from shop2020.model.v1.order.impl import DataService
from shop2020.model.v1.order.impl.DataAccessors import get_order,\
    order_outofstock, close_session

VALUES_TO_NAMES = {
    0: "PAYMENT_PENDING",
    1: "PAYMENT_FAILED",
    2: "INIT",
    3: "SUBMITTED_FOR_PROCESSING",
    4: "ACCEPTED",
    5: "INVENTORY_LOW",
    6: "REJECTED",
    7: "BILLED",
    8: "READY_FOR_SHIPPING",
    9: "SHIPPED_FROM_WH",
    10: "SHIPPED_TO_LOGST",
    11: "IN_TRANSIT",
    12: "DELIVERY_SUCCESS",
    13: "DELIVERY_FAILED_FIRST_ATTEMPT",
    14: "DELIVERY_FAILED_SECOND_ATTEMPT",
    15: "DELIVERY_FAILED_THIRD_ATTEMPT",
    16: "DELIVERY_FAILED_WORNG_ADDRESS",
    17: "COMPLETED",
    18: "CANCELED",
    19: "FAILED",
  }

def mark_order_as_picked_up(order):
    '''
    Mark order as picked up
    '''
    if order.status != OrderStatus.SHIPPED_FROM_WH:
        print "Has this order been picked up?"
        print
        print "In case it has been and the same was not updated in the database, please first mark this order as picked up and then try again."
        return

    raw_pickup_timestamp = raw_input("Enter pickup time in YYYY-MM-DD hhmm format: ")
    try:
        pickup_timestamp = get_py_datetime(raw_pickup_timestamp)
        print("Pick up timestamp: " + str(pickup_timestamp))
    except ValueError:
        print("Invalid pickup time")
        return
   
    order.status = OrderStatus.SHIPPED_TO_LOGST
    order.statusDescription = "Order picked up by Courier Company"
    order.pickup_timestamp = pickup_timestamp 
    session.commit()

def mark_order_as_delivered(order):
    '''
    Mark order as delivered
    '''
    if order.status != OrderStatus.SHIPPED_TO_LOGST:
        print "Has this order been picked up?"
        print
        print "In case it has been and the same was not updated in the database, please first mark this order as picked up and then try again."
        return

    raw_delivery_timestamp = raw_input("Enter delivery time in YYYY-MM-DD hhmm format: ")
    try:
        delivery_timestamp = get_py_datetime(raw_delivery_timestamp)
    except ValueError:
        print("Invalid delivery time stamp")
        return
    
    receiver = raw_input("Enter the name of receiver: ")
    if receiver is None or receiver == "":
        print("Receiver info is mandatory.")
        return
    
    order.status = OrderStatus.DELIVERY_SUCCESS
    order.statusDescription = "Order delivered"
    order.delivery_timestamp = delivery_timestamp
    order.receiver = receiver
    session.commit()


def mark_order_as_failed(order):
    '''
    Mark order as failed
    '''
    if order.status != OrderStatus.SHIPPED_TO_LOGST:
        print "Has this order been picked up?"
        print
        print "In case it has been and the same was not updated in the database, please first mark this order as picked up and then try again."
        return

    raw_delivery_timestamp = raw_input("Enter delivery time in YYYY-MM-DD hhmm format: ")
    try:
        delivery_timestamp = get_py_datetime(raw_delivery_timestamp)
    except ValueError:
        print("Invalid delivery timestamp")
        return
    
    reason = raw_input("Enter the reason for failure: ")
    if reason is None or reason == "":
        print("Reason for failure is mandatory.")
        return
    
    order.status = OrderStatus.FAILED
    order.delivery_timestamp = delivery_timestamp 
    order.statusDescription = "Order Returned to Origin:" + reason
    session.commit()

def change_product(order):
    '''
    Ship a product of a different color to the customer.
    '''
    if order.status not in [OrderStatus.INIT, OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW]:
        print "This order has already been processed. Please seek help from engineering."
        return
    
    raw_item_id = raw_input("Enter the ID of the item that you want to ship: ")
    try:
        item_id = int(raw_item_id)
    except ValueError:
        print("Invalid product Id")
        return
    
    color = raw_input("Enter the color of the new item: ")
    if color is None or color == "":
        print("Color information is mandatory.")
        return
    
    #warehouse_id = raw_input("Enter the warehouse id which will fulfil this order. Leave empty to keep it unchanged: ")
    #if warehouse_id is None or warehouse_id == "":
    #    warehouse_id = order.warehouse_id
    
    lineitem = order.lineitems[0]
    
    catalog_client = CatalogClient().get_client()
    catalog_client.reserveItemInWarehouse(item_id, order.warehouse_id, lineitem.quantity)
    catalog_client.reduceReservationCount(lineitem.item_id, order.warehouse_id, lineitem.quantity)
    #TODO: Check that this new item has the same price
        
    lineitem.item_id = item_id
    lineitem.color = color
    
    session.commit()

def change_warehouse(order):
    '''
    Update the warehouse which will be used to fulfil this order.
    '''
    if order.status not in [OrderStatus.INIT, OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW]:
        print "This order has already been processed. Please seek help from engineering."
        return
    
    print("Current Warehouse: " + str(order.warehouse_id))
    
    raw_warehouse_id = raw_input("Enter the ID of the warehouse from where you want to ship: ")
    try:
        warehouse_id = int(raw_warehouse_id)
    except ValueError:
        print("Invalid warehouse id")
        return
      
    if warehouse_id == order.warehouse_id:
        print("You have selected the current warehouse again. Nothing to do")
        return

    lineitem = order.lineitems[0]
    catalog_client = CatalogClient().get_client()
    catalog_client.reserveItemInWarehouse(lineitem.item_id, warehouse_id, lineitem.quantity)
    catalog_client.reduceReservationCount(lineitem.item_id, order.warehouse_id, lineitem.quantity)
    
    order.warehouse_id = warehouse_id
    session.commit()

def update_weight(order):
    '''
    Update the weight of order
    '''
    raw_weight = raw_input("Enter the final weight to be set: ")
    try:
        weight = float(raw_weight)
    except ValueError:
        print("Invalid weight")
        return
    
    order.total_weight = weight
    lineitem = order.lineitems[0]
    lineitem.total_weight = weight
    lineitem.unit_weight = weight
    #TODO: Update the weight of item. Problem is that even then, this update will only go to Production and not to Staging. Next content update will wipe out this data.
    session.commit()

def cancel(order):
    '''
    Cancel
    '''
    print("Your session has been closed")
    return

ACTIONS = {0: cancel,
           1: order_outofstock,
           2: mark_order_as_picked_up,
           3: mark_order_as_delivered,
           4: mark_order_as_failed,
           5: change_product,
           6: change_warehouse,
           7: update_weight
           }

def get_py_datetime(time_string):
    time_format = "%Y-%m-%d %H%M"
    mytime = time.strptime(time_string, time_format)
    return datetime.datetime(*mytime[:6])

def main():
    parser = optparse.OptionParser()
    parser.add_option("-H", "--host", dest="hostname",
                      default="localhost",
                      type="string", help="The HOST where the DB server is running",
                      metavar="HOST")
    (options, args) = parser.parse_args()
    if len(args) != 0:
        parser.error("You've supplied extra arguments. Are you sure you want to run this program?")
    DataService.initialize(db_hostname=options.hostname, echoOn=False)
    raw_order_id = raw_input("Enter Order Id which you want to modify:")
    try:
        order_id = int(raw_order_id)
        print("You want to modify: " + str(order_id))
    except ValueError:
        print("Invalid Order Id.")
        return
    
    try:
        order = get_order(order_id)
        print("Please check the details of the order below and ensure that it's the same order which you want to modify:")
        print("Order Id:\t\t" + str(order.id))
        print("Customer Name:\t\t" + order.customer_name)
        print("Address Line 1:\t\t" + order.customer_address1)
        print("Address Line 2:\t\t" + order.customer_address2)
        print("City:\t\t\t" + order.customer_city)
        print("State:\t\t\t" + order.customer_state)
        print("Pincode:\t\t" + order.customer_pincode)
        print("Amount:\t\t\t" + str(order.total_amount))
        print("Created On:\t\t" + str(order.created_timestamp))
        #print("Billed On:\t" + str(order.billing_timestamp))
        #print("Shipped On:\t" + str(order.shipping_timestamp))
        print("Current Status:\t\t" + VALUES_TO_NAMES[order.status])
        print("Status Description:\t" + order.statusDescription)
        print("Ordered Items description:")
        for lineitem in order.lineitems:
            print("Item Id:" + str(lineitem.item_id) + "\tBrand: " + str(lineitem.brand) + "\tModel: " + str(lineitem.model_number) + "\tColor: " + str(lineitem.color))
        print
        print
        print("You can perform following operations:")
        for (key, val) in ACTIONS.iteritems():
            print("[" + str(key) + "]" + val.__doc__ )

        raw_action = raw_input("What do you want to do? ")
        if raw_action is None or raw_action == "":
            print("Your session has been closed.")
            return
        try:
            action = int(raw_action)
        except ValueError:
            print("Invalid input.")
            return
        if action > max(ACTIONS.keys()):
            print("Invalid input.")
            return
        ACTIONS[action](order)
    except TransactionServiceException as tsex:
        print tsex.message
    finally:
        close_session()
    
if __name__ == '__main__':
    main()