Subversion Repositories SmartDukaan

#!/usr/bin/python
'''
It processes the following orders:
 1. Orders in DOA_PICKUP_CONFIRMED status : get details of orders that 
     were in DOA_PICKUP_CONFIRMED status from database and 
     calls BlueDart api to know whether they are picked up by BlueDart
     and changes the status to DOA_RETURN_IN_TRANSIT if it is done.
 2. Orders in RET_PICKUP_CONFIRMED status : get details of orders that 
     were in RET_PICKUP_CONFIRMED status from database and 
     calls BlueDart api to know whether they are picked up by BlueDart
     and changes the status to RET_RETURN_IN_TRANSIT if it is done.
 3. Orders in SHIPPED_FROM_WH status: get details of orders that
     were in SHIPPED_FROM_WH status from database and 
     calls BlueDart api to know whether they are picked up by BlueDart
     and changes the status to SHIPPED_TO_LOGST if it is done.
 4. Orders in SHIPPED_TO_LOGST status: get details of orders that
     were in SHIPPED_TO_LOGST status from database and 
     calls BlueDart api to know their status and changes the status accordingly.

It sends out a Pickup mismatch report, Return orders Pickup Mismatch report, Doa Pickup mismatch report,
Undelivered orders report and Returned Orders report to cnc.center@shop2020.in

http://www.bluedart.com/servlet/RoutingServlet?handler=tnt&action=custawbquery&loginid=DEL24119&awb=ref&format=XML&lickey=6265d61bafa6292c5ddfdb1ee335ca80&verno=1.3&scan=1&numbers={variable1} is hard coded
to track DOA orders and for other orders ConfigClient is called to get bluedart_update_url

@author: Phani Kumar
'''
from LogisticUtils import enqueueMailForFDA
from shop2020.clients.CRMClient import CRMClient
from shop2020.clients.LogisticsClient import LogisticsClient
from shop2020.clients.TransactionClient import TransactionClient
from shop2020.clients.UserClient import UserClient
from shop2020.config.client.ConfigClient import ConfigClient
from shop2020.model.v1.order.script.LogisticUtils import \
    create_crm_tickets_for_delivey_attempted_orders
from shop2020.thriftpy.config.ttypes import ConfigException
from shop2020.thriftpy.crm.ttypes import *
from shop2020.thriftpy.model.v1.order.ttypes import TransactionServiceException, \
    OrderStatus
from shop2020.utils.EmailAttachmentSender import get_attachment_part, mail
from shop2020.utils.Utils import to_py_date
from xml.etree.ElementTree import parse
import csv
import datetime
import optparse
import sys
import time
import traceback
import urllib2

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


try:
    config_client = ConfigClient()
    BLUEDART_URL = config_client.get_property("bluedart_update_url")
except ConfigException as cex:
    print cex.message
    traceback.print_exc()

defaultUndeliveredAsssigneeId = 65
dtrUndeliveredAsssigneeId = 33
from_user = 'cnc.center@shop2020.in'
from_pwd = '5h0p2o2o'
to = ['kshitij.sood@saholic.com', "ritesh.chauhan@shop2020.in","amit.gupta@shop2020.in"]

def process_dao_pickup_orders(provider):
    try:
        doas_tobe_picked_up = fetch_data(provider.id, [OrderStatus.DOA_PICKUP_CONFIRMED])
        doa_pickup_details = read_dao_return_pickup_orders(doas_tobe_picked_up)
        if doa_pickup_details:
            update_picked_doas(provider.id, doa_pickup_details)
    except:
        print "Some issue while processing the orders in DOA_PICKUP_CONFIRMED status"
        traceback.print_exc()

def process_return_pickup_orders(provider):
    try:
        returns_tobe_picked_up = fetch_data(provider.id, [OrderStatus.RET_PICKUP_CONFIRMED])
        returns_pickup_details = read_dao_return_pickup_orders(returns_tobe_picked_up)
        if returns_pickup_details:
            update_picked_returns(provider.id, returns_pickup_details)
    except:
        print "Some issue while processing the orders in RET_PICKUP_CONFIRMED status"
        traceback.print_exc()

def process_pickup_records(provider):
    try:
        orders_tobe_picked_up = fetch_data(provider.id, [OrderStatus.SHIPPED_FROM_WH])
        pickup_details = read_pickup_orders(orders_tobe_picked_up)
        if pickup_details:
            update_picked_orders(provider.id, pickup_details)
    except:
        print "Some issue while processing the orders in SHIPPED_FROM_WH status"
        traceback.print_exc()

def process_local_connection_orders(provider):
    try:
        orders_tobe_local_connected = fetch_data(provider.id, [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST])
        local_connected_orders = read_local_connection_orders(orders_tobe_local_connected)
        if local_connected_orders:
            update_local_connected_orders(provider.id, local_connected_orders)
    except:
        print "Some issue while processing the orders for local connection status"
        traceback.print_exc()

def process_reached_destination_city_orders(provider):
    try:
        orders_tobe_reached_destination_city = fetch_data(provider.id, [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY])
        destination_city_reached_orders = read_reached_destination_orders(orders_tobe_reached_destination_city)
        if destination_city_reached_orders:
            update_destination_city_reached_orders(provider.id, destination_city_reached_orders)
    except:
        print "Some issue while processing the orders for Reached Destination City status"
        traceback.print_exc()

def process_first_delivery_attempt_orders(provider):
    try:
        orders_tobe_first_delivery_attempted = fetch_data(provider.id, [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY])
        first_atdl_orders = read_first_delivery_attempt_orders(orders_tobe_first_delivery_attempted)
        if first_atdl_orders:
            update_first_atdl_orders(provider.id, first_atdl_orders)
    except:
        print "Some issue while processing the orders for First delivery attempt status"
        traceback.print_exc()

def process_delivery_report(provider):
    try:
        orders_tobe_delivered = fetch_data(provider.id, [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY, OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.RTO_IN_TRANSIT])
        delivered_orders, returned_orders, undelivered_orders = read_delivery_orders(orders_tobe_delivered)
        if delivered_orders:
            update_delivered_orders(provider.id, delivered_orders)
        if returned_orders:
            update_returned_orders(provider.id, returned_orders)
        if undelivered_orders:
            update_reason_of_undelivered_orders(provider.id, undelivered_orders)
    except:
        print "Some issue while processing the orders for delivery status"
        traceback.print_exc()

def generate_reports(provider):
    get_doas_not_picked_up(provider)
    get_returns_not_picked_up(provider)
    get_orders_not_picked_up(provider)
    get_orders_pending_local_connection(provider)
    get_returned_orders(provider)
    get_orders_not_delivered(provider)

def get_doas_not_picked_up(provider):
    txnClient = TransactionClient().get_client()
    try:
        doas_not_picked_up = txnClient.getDoasNotPickedUp(provider.id)
    except TransactionServiceException as tex:
        print tex.message
    
    try:
        if doas_not_picked_up:
            print "DOAs not Picked up:"
            print doas_not_picked_up
            mismatch_file = "/tmp/BlueDart_DoaPickupMismatch.csv"
            print "Some of our DOA orders were not picked up. Printing report to:" + mismatch_file
            print_dao_return_pickup_mismatch_report(mismatch_file, doas_not_picked_up)
            pickup_mismatch_part = [get_attachment_part(mismatch_file)]
            mail(from_user, from_pwd, to,\
                 "DOA Pickup Mismatch for " + provider.name,\
                 "This is a system generated email.Please don't reply to it.",\
                 pickup_mismatch_part)
    except Exception:
        print "Some issue sending the DOA mismatch report"
        traceback.print_exc()

def get_returns_not_picked_up(provider):
    txnClient = TransactionClient().get_client()
    try:
        returns_not_picked_up = txnClient.getReturnOrdersNotPickedUp(provider.id)
    except TransactionServiceException as tex:
        print tex.message
    
    try:
        if returns_not_picked_up:
            print "Return Orders not Picked up:"
            print returns_not_picked_up
            mismatch_file = "/tmp/BlueDart_ReturnsPickupMismatch.csv"
            print "Some of our Return orders were not picked up. Printing report to:" + mismatch_file
            print_dao_return_pickup_mismatch_report(mismatch_file, returns_not_picked_up)
            pickup_mismatch_part = [get_attachment_part(mismatch_file)]
            mail(from_user, from_pwd, to,\
                 "Return orders Pickup Mismatch for " + provider.name,\
                 "This is a system generated email.Please don't reply to it.",\
                 pickup_mismatch_part)
    except Exception:
        print "Some issue sending the Return orders mismatch report"
        traceback.print_exc()

def get_orders_not_picked_up(provider):
    txnClient = TransactionClient().get_client()
    try:
        orders_not_picked_up = txnClient.getOrdersNotPickedUp(provider.id)
    except TransactionServiceException as tex:
        print tex.message
    
    try:
        if orders_not_picked_up:
            print "Orders not Picked up:"
            print orders_not_picked_up
            mismatch_file = "/tmp/BlueDart_PickupMismatch.csv"
            print "Some of our orders were not picked up. Printing report to:" + mismatch_file
            print_pickup_mismatch_report(mismatch_file, orders_not_picked_up)
            pickup_mismatch_part = [get_attachment_part(mismatch_file)]
            mail(from_user, from_pwd, to,\
                 "Order Pickup Mismatch for " + provider.name,\
                 "This is a system generated email.Please don't reply to it.",\
                 pickup_mismatch_part)
    except Exception:
        print "Some issue sending the pickup mismatch report"
        traceback.print_exc()

def get_orders_pending_local_connection(provider):
    txnClient = TransactionClient().get_client()
    try:
        orders_pending_local_connection = txnClient.getOrdersNotLocalConnected(provider.id)
    except TransactionServiceException as tex:
        print tex.message
    
    try:
        if orders_pending_local_connection:
            print "Local Connection Pending Orders:"
            print orders_pending_local_connection
            mismatch_file = "/tmp/BlueDart_LocalConnectionPendingOrders.csv"
            print "Some of our Orders were not Shipped to Destination yet. Printing report to:" + mismatch_file
            print_undelivered_orders_report(mismatch_file, orders_pending_local_connection)
            pickup_mismatch_part = [get_attachment_part(mismatch_file)]
            mail(from_user, from_pwd, to,\
                 "Orders that are not Shipped to Destination yet for " + provider.name,\
                 "This is a system generated email.Please don't reply to it.",\
                 pickup_mismatch_part)
    except Exception:
        print "Some issue updating and sending the Local Connection orders report"
        traceback.print_exc()

def get_returned_orders(provider):
    txnClient = TransactionClient().get_client()
    try:
        returned_orders = txnClient.getRTOrders(provider.id)
    except TransactionServiceException as tex:
        print tex.message
    
    try:
        if returned_orders:
            print "Returned Orders:"
            print returned_orders
            returned_orders_file = "/tmp/BlueDart_ReturnedOrders.csv"
            print "Some of our Orders were returned by logistics provider. Printing report to:" + returned_orders_file
            print_rto_orders_report(returned_orders_file, returned_orders)
            returned_orders_report = [get_attachment_part(returned_orders_file)]
            mail(from_user, from_pwd, to,\
                 "Returned Orders Report for " + provider.name,\
                 "This is a system generated email.Please don't reply to it.",\
                 returned_orders_report)
    except:
        print "Some issue sending the returned orders report"
        traceback.print_exc()

def get_orders_not_delivered(provider):
    txnClient = TransactionClient().get_client()
    try:
        orders_not_delivered = txnClient.getNonDeliveredOrdersbyCourier(provider.id)
    except TransactionServiceException as tex:
        print tex.message
    
    try:
        if orders_not_delivered:
            print "Undelivered Orders:"
            print orders_not_delivered
            mismatch_file = "/tmp/BlueDart_UndeliveredOrders.csv"
            print "Some of our Orders were not delivered. Printing report to:" + mismatch_file
            print_undelivered_orders_report(mismatch_file, orders_not_delivered)
            pickup_mismatch_part = [get_attachment_part(mismatch_file)]
            mail(from_user, from_pwd, to,\
                 "Orders that are undelivered but picked up or shipped four days ago for " + provider.name,\
                 "This is a system generated email.Please don't reply to it.",\
                 pickup_mismatch_part)
    except Exception:
        print "Some issue updating and sending the undelivered orders report"
        traceback.print_exc()

def get_provider_by_name(provider_name):
    logistics_client = LogisticsClient().get_client()
    provider = None
    providers = logistics_client.getAllProviders()
    for p in providers:
        if p.name == provider_name:
            provider=p
            break
    if provider == None:
        sys.exit("Can't continue execution: No such provider")
    return provider

def fetch_data(provider_id, order_status_list):
    txnClient = TransactionClient().get_client()
    try:
        doas_tobe_picked_up = txnClient.getOrdersForProviderForStatus(provider_id, order_status_list)
        return doas_tobe_picked_up
    except TransactionServiceException as tex:
        print tex.message

def read_dao_return_pickup_orders(orders_tobe_picked_up):
    #uri=http://www.bluedart.com/servlet/RoutingServlet?handler=tnt&action=custawbquery&loginid=DEL24119&awb=ref&format=XML&lickey=6265d61bafa6292c5ddfdb1ee335ca80&verno=1.3&scan=1&numbers=82390
    picked_up_orders = {}
    for order in orders_tobe_picked_up:
        try:
            uri = 'http://www.bluedart.com/servlet/RoutingServlet?handler=tnt&action=custawbquery&loginid=DEL24119&awb=ref&format=XML&lickey=6265d61bafa6292c5ddfdb1ee335ca80&verno=1.3&scan=1&numbers=' + str(order.pickupRequestNo)
            root = parse(urllib2.urlopen(uri)).getroot()
            children = root.getchildren()
            for child in children:
                nodes = child.findall('Scans/ScanDetail')
                for element in reversed(nodes):
                    datestring = element.findtext('ScanDate', '')
                    timestring = element.findtext('ScanTime', '')
                    delivery_date = get_py_datetime(datestring, timestring)
                    picked_up_orders[order.pickupRequestNo] = str(delivery_date)
                    break
                break
        except:
            pass
    
    print "Picked up Orders:"
    print picked_up_orders
    return picked_up_orders

def read_pickup_orders(orders_tobe_picked_up):
    picked_up_orders = {}
    for order in orders_tobe_picked_up:
        try:
            uri = BLUEDART_URL + order.airwaybill_no
            root = parse(urllib2.urlopen(uri)).getroot()
            children = root.getchildren()
            for child in children:
                nodes = child.findall('Scans/ScanDetail')
                for element in reversed(nodes):
                    datestring = element.findtext('ScanDate', '')
                    timestring = element.findtext('ScanTime', '')
                    delivery_date = get_py_datetime(datestring, timestring)
                    picked_up_orders[order.airwaybill_no] = str(delivery_date)
                    break
                break
        except:
            pass
    
    print "Picked up Orders:"
    print picked_up_orders
    return picked_up_orders

def read_local_connection_orders(orders_tobe_local_connected):
    local_connected_orders = {}
    for order in orders_tobe_local_connected:
        try:
            uri = BLUEDART_URL + order.airwaybill_no
            root = parse(urllib2.urlopen(uri)).getroot()
            children = root.getchildren()
            for child in children:
                nodes = child.findall('Scans/ScanDetail')
                for element in reversed(nodes):
                    #Start:- Added By Manish Sharma for Making changes in case of Orders dispatched from Mumbai Warehouse on 26-Jun-2013
                    #Start:- Modified By Manish Sharma for Making changes in case of Orders dispatched from Bhiwandi Warehouse on 29-Jul-2013
                    if (getTrimedString(element.findtext('ScannedLocation', '')) == getTrimedString('OVALI WAREHOUSE') or getTrimedString(element.findtext('ScannedLocation', '')) == getTrimedString('TARDEO') or getTrimedString(element.findtext('ScannedLocation', '')) == getTrimedString('MUMBAI HUB')) and element.findtext('ScanType', '') == 'UD' and getTrimedString(element.findtext('Scan', '')) == getTrimedString('SHIPMENT OUTSCANNED TO NETWORK'):
                        datestring = element.findtext('ScanDate', '')
                        timestring = element.findtext('ScanTime', '')
                        delivery_date = get_py_datetime(datestring, timestring)
                        local_connected_orders[order.airwaybill_no] = str(delivery_date)
                        break
                    if (getTrimedString(element.findtext('ScannedLocation', '')) == getTrimedString('RAMA ROAD HUB') or getTrimedString(element.findtext('ScannedLocation', '')) == getTrimedString('DELHI HUB')) and element.findtext('ScanType', '') == 'UD' and getTrimedString(element.findtext('Scan', '')) == getTrimedString('SHIPMENT OUTSCANNED TO NETWORK'):
                        datestring = element.findtext('ScanDate', '')
                        timestring = element.findtext('ScanTime', '')
                        delivery_date = get_py_datetime(datestring, timestring)
                        local_connected_orders[order.airwaybill_no] = str(delivery_date)
                        break
                    #End:- Modified By Manish Sharma for Making changes in case of Orders dispatched from Bhiwandi Warehouse on 29-Jul-2013
                    #End:- Added By Manish Sharma for Making changes in case of Orders dispatched from Mumbai Warehouse on 26-Jun-2013
                break
        except:
            pass
    
    print "Local Connected Orders"
    print local_connected_orders
    
    return local_connected_orders

def read_reached_destination_orders(orders_tobe_reached_destination_city):
    destination_city_reached_orders = {}
    for order in orders_tobe_reached_destination_city:
        try:
            uri = BLUEDART_URL + order.airwaybill_no
            root = parse(urllib2.urlopen(uri)).getroot()
            children = root.getchildren()
            child_number = 0
            for child in children:
                child_number = child_number + 1
                nodes = child.findall('Scans/ScanDetail')
                orderstatus = None
                for element in nodes:
                    if element.findtext('ScanType', '') == 'UD' and (getTrimedString(element.findtext('Scan', '')) == getTrimedString('Shipment Inscan') or getTrimedString(element.findtext('Scan', '')) == getTrimedString('Shipment-Autoscan')) and element.findtext('ScannedLocation', '') == child.findtext('Destination', ''):
                        datestring = element.findtext('ScanDate', '')
                        timestring = element.findtext('ScanTime', '')
                        delivery_date = get_py_datetime(datestring, timestring)
                        destination_city_reached_orders[order.airwaybill_no] = str(delivery_date)
                        orderstatus = 'UD'
                        break
                    elif element.findtext('ScanType', '') == 'RD':
                        if child_number < len(children):
                            orderstatus = 'RD'
                            break
                if orderstatus != 'RD':
                    break
        except:
            pass
    
    print "Destination City Reached Orders"
    print destination_city_reached_orders
    
    return destination_city_reached_orders

def read_first_delivery_attempt_orders(orders_tobe_first_delivery_attempted):
    first_atdl_orders = {}
    for order in orders_tobe_first_delivery_attempted:
        try:
            uri = BLUEDART_URL + order.airwaybill_no
            root = parse(urllib2.urlopen(uri)).getroot()
            children = root.getchildren()
            child_number = 0
            for child in children:
                child_number = child_number + 1
                nodes = child.findall('Scans/ScanDetail')
                orderstatus = None
                node_number = len(nodes)-1
                for element in reversed(nodes):
                    if element.findtext('ScanType', '') == 'UD' and getTrimedString(element.findtext('Scan', '')) == getTrimedString('Shipment Outscan'):
                        if node_number != 0 and nodes[node_number-1].findtext('ScanType', '') == 'UD':
                            element = nodes[node_number-1]
                            datestring = element.findtext('ScanDate', '')
                            timestring = element.findtext('ScanTime', '')
                            delivery_date = get_py_datetime(datestring, timestring)
                            reason_for_nondelivery = element.findtext('Scan', '')
                            first_atdl_orders[order.airwaybill_no] = str(delivery_date) + "|" + reason_for_nondelivery
                        orderstatus = 'UD'
                        break
                    elif element.findtext('ScanType', '') == 'UD' and getTrimedString(element.findtext('Scan', '')) == getTrimedString("Shpt Held At Destination As Per Shipper's Request"):
                        datestring = element.findtext('ScanDate', '')
                        timestring = element.findtext('ScanTime', '')
                        delivery_date = get_py_datetime(datestring, timestring)
                        reason_for_nondelivery = element.findtext('Scan', '')
                        first_atdl_orders[order.airwaybill_no] = str(delivery_date) + "|" + reason_for_nondelivery
                        orderstatus = 'UD'
                        break
                    elif element.findtext('ScanType', '') == 'RD':
                        if child_number < len(children):
                            orderstatus = 'RD'
                            break
                    node_number = node_number - 1
                if orderstatus != 'RD':
                    break
        except:
            pass
    
    print "FIRST DELIVERY ATTEMPT MADE Orders"
    print first_atdl_orders
    
    return first_atdl_orders

def read_delivery_orders(orders_tobe_delivered):
    delivered_orders = {}
    returned_orders = {}
    undelivered_orders = {}
    for order in orders_tobe_delivered:
        try:
            uri = BLUEDART_URL + order.airwaybill_no
            root = parse(urllib2.urlopen(uri)).getroot()
            children = root.getchildren()
            child_number = 0
            for child in children:
                child_number = child_number + 1
                nodes = child.findall('Scans/ScanDetail')
                orderstatus = None
                if len(nodes):
                    node_number = len(nodes)-1
                    for element in reversed(nodes):
                        if element.findtext('ScanType', '') == 'DL' and getTrimedString(element.findtext('Scan', '')) == getTrimedString('Shipment delivered'):
                            orderstatus = 'DL'
                            datestring = element.findtext('ScanDate', '')
                            timestring = element.findtext('ScanTime', '')
                            delivery_date = get_py_datetime(datestring, timestring)
                            receiver = child.findtext('ReceivedBy', '')
                            delivered_orders[order.airwaybill_no] = str(delivery_date) + "|" +  receiver
                            break
                        elif element.findtext('ScanType', '') == 'RT':
                            orderstatus = 'RT'
                            datestring = element.findtext('ScanDate', '')
                            timestring = element.findtext('ScanTime', '')
                            delivery_date = get_py_datetime(datestring, timestring)
                            if node_number < len(nodes)-1:
                                reason_for_return = nodes[node_number+1].findtext('Scan', '')
                            else:
                                reason_for_return = element.findtext('Scan', '')
                            returned_orders[order.airwaybill_no] = str(delivery_date) + "|" + reason_for_return
                            break
                        elif element.findtext('ScanType', '') == 'RD':
                            if child_number < len(children):
                                orderstatus = 'RD'
                                break
                        elif node_number == 0:
                            if child.findtext('StatusType', '') == 'RT':
                                orderstatus = 'RT'
                                datestring = child.findtext('ScanDate', '')
                                timestring = child.findtext('ScanTime', '')
                                delivery_date = get_py_datetime(datestring, timestring)
                                reason_for_return = child.findtext('Status', '')
                                returned_orders[order.airwaybill_no] = str(delivery_date) + "|" + reason_for_return
                                break
                            elif child.findtext('StatusType', '') == 'DL' and getTrimedString(child.findtext('Scan', '')) == getTrimedString('Shipment delivered'):
                                orderstatus = 'DL'
                                datestring = child.findtext('ScanDate', '')
                                timestring = child.findtext('ScanTime', '')
                                delivery_date = get_py_datetime(datestring, timestring)
                                receiver = child.findtext('ReceivedBy', '')
                                delivered_orders[order.airwaybill_no] = str(delivery_date) + "|" +  receiver
                                break
                            else:
                                orderstatus = 'UD'
                                reason = child.findtext('Status', '')
                                undelivered_orders[order.airwaybill_no] = reason
                                break
                        node_number = node_number - 1
                else:
                    if child_number > 1:
                        reason = children[child_number-1].findtext('Status', '')
                        undelivered_orders[order.airwaybill_no] = reason
                if orderstatus != 'RD':
                    break
        except:
            pass
    
    print "Delivered Orders:"
    print delivered_orders
    
    print "Returned Orders:"
    print returned_orders
    
    print "Undelivered Orders"
    print undelivered_orders
    
    return delivered_orders, returned_orders, undelivered_orders

def update_picked_orders(provider_id, pickup_details):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markOrdersAsPickedUp(provider_id, pickup_details)
    except TransactionServiceException as tex:
        print tex.message

def update_picked_doas(provider_id, doa_pickup_details):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markDoasAsPickedUp(provider_id, doa_pickup_details)
    except TransactionServiceException as tex:
        print tex.message

def update_picked_returns(provider_id, returns_pickup_details):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markReturnOrdersAsPickedUp(provider_id, returns_pickup_details)
    except TransactionServiceException as tex:
        print tex.message

def update_delivered_orders(provider_id, delivered_orders):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markOrdersAsDelivered(provider_id, delivered_orders)
    except TransactionServiceException as tex:
        print tex.message

def update_returned_orders(provider_id, returned_orders):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markAsRTOrders(provider_id, returned_orders)
    except TransactionServiceException as tex:
        print tex.message

def update_reason_of_undelivered_orders(provider_id, undelivered_orders):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.updateNonDeliveryReason(provider_id, undelivered_orders)
    except TransactionServiceException as tex:
        print tex.message

def update_local_connected_orders(provider_id, local_connected_orders):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markOrdersAsLocalConnected(provider_id, local_connected_orders)
    except TransactionServiceException as tex:
        print tex.message

def update_destination_city_reached_orders(provider_id, destination_city_reached_orders):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markOrdersAsDestinationCityReached(provider_id, destination_city_reached_orders)
    except TransactionServiceException as tex:
        print tex.message

def update_first_atdl_orders(provider_id, first_atdl_orders):
    txnClient = TransactionClient().get_client()
    try:
        txnClient.markOrdersAsFirstDeliveryAttempted(provider_id, first_atdl_orders)
    except TransactionServiceException as tex:
        print tex.message

def print_pickup_mismatch_report(filename, orders):
    writer = csv.writer(open(filename, "wb"), delimiter=',', quoting=csv.QUOTE_NONE)
    writer.writerow(['Order Id', 'AWB No', 'Shipping timestamp'])
    for order in orders:
        writer.writerow([order.id, order.airwaybill_no, to_py_date(order.shipping_timestamp)])

def print_dao_return_pickup_mismatch_report(filename, orders):
    writer = csv.writer(open(filename, "wb"), delimiter=',', quoting=csv.QUOTE_NONE)
    writer.writerow(['Order Id', 'Pickup Request No', 'Authorization timestamp'])
    for order in orders:
        writer.writerow([order.id, order.pickupRequestNo, to_py_date(order.doa_auth_timestamp)])

def print_rto_orders_report(filename, orders):
    writer = csv.writer(open(filename, "wb"), delimiter=',', quoting=csv.QUOTE_NONE)
    writer.writerow(['Order Id', 'AWB No', 'Return date', 'Reason'])
    for order in orders:
        statusDescription = ''
        if order.statusDescription is not None:
            statusDescription = order.statusDescription.replace(","," ")
        writer.writerow([order.id, order.airwaybill_no, to_py_date(order.delivery_timestamp), statusDescription])

def print_undelivered_orders_report(filename, orders):
    writer = csv.writer(open(filename, "wb"), delimiter=',', quoting=csv.QUOTE_NONE)
    writer.writerow(['Order Id', 'AWB No', 'Status', 'Status Description', 'Shipping timestamp', 'Pickup timestamp', 'Promised delivery date', 'Expected delivery date', 'OTG'])
    for order in orders:
        statusDescription = ''
        if order.statusDescription is not None:
            statusDescription = order.statusDescription.replace(","," ")
        writer.writerow([order.id, order.airwaybill_no, order.status, statusDescription, to_py_date(order.shipping_timestamp), to_py_date(order.pickup_timestamp), to_py_date(order.promised_delivery_time), to_py_date(order.expected_delivery_time), 'True'  if order.otg else 'False'])

def auto_close_crm_tickets_created():
    try:
        ticket_created_orders = []
        tickets_map = {}
        crmServiceClient = CRMClient().get_client()
        searchFilter = SearchFilter()
        searchFilter.ticketCategory = TicketCategory.UNDELIVERED
        searchFilter.ticketAssigneeIds = [defaultUndeliveredAsssigneeId]
        searchFilter.ticketPriority = TicketPriority.HIGH
        searchFilter.ticketStatuses = [TicketStatus.OPEN]
        tickets = crmServiceClient.getTickets(searchFilter)
        print tickets
        for old_ticket in tickets:
            ticket_created_orders.append(old_ticket.orderId)
            tickets_map[old_ticket.orderId] = old_ticket
        print ticket_created_orders
        txnClient = TransactionClient().get_client()
        orders = txnClient.getOrderList(ticket_created_orders)
        for order in orders:
            if order.status not in [OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.RTO_IN_TRANSIT]:
                old_ticket = tickets_map.get(order.id)
                old_ticket.status = TicketStatus.CLOSED
                activity = Activity()
                activity.creatorId = 1
                activity.ticketAssigneeId = old_ticket.assigneeId
                activity.type = ActivityType.OTHER
                activity.description = "Ticket Closed bcoz order status changed to:" + order.statusDescription
                activity.ticketCategory = old_ticket.category
                activity.ticketDescription = old_ticket.description
                activity.ticketPriority = old_ticket.priority
                activity.ticketStatus = old_ticket.status
                
                if old_ticket.customerId is None or old_ticket.customerId == -1:
                    activity.customerEmailId = old_ticket.customerEmailId
                    activity.customerMobileNumber = old_ticket.customerMobileNumber
                    activity.customerName = old_ticket.customerName
                else:
                    activity.customerId = old_ticket.customerId
                
                crmServiceClient.updateTicket(old_ticket, activity)
    except:
        print "Some issue while closing crm tickets for orders in DELIVERY_SUCCESS status"
        traceback.print_exc()

def get_py_datetime(datestring, timestring):
    # This should be a command line argument.
    # Refer http://docs.python.org/library/time.html#time.strftime to
    # get a complete list of format specifiers available for date time.
    if datestring == '':
        return None
    if datestring.find('-') == -1:
        time_format = "%d %B %Y %H:%M:%S"
    else:
        time_format = "%d-%b-%Y %H:%M:%S"
    if timestring == '':
        timestring = '00:00:00'
    time_array = timestring.split(':')
    if len(time_array) < 3:
        timestring = timestring + ':00'
    time_string = datestring + ' ' + timestring
    mytime = time.strptime(time_string, time_format)
    return datetime.datetime(*mytime[:6])

def getTrimedString(text):
    if text is None or text == '':
        return ''
    else:
        text = text.strip().lower()
        text_list = list(text)
        new_text = ''
        for letter in text_list:
            if letter.isalnum():
                new_text = new_text + str(letter)
        return new_text

def main():
    parser = optparse.OptionParser()
    parser.add_option("-p", "--pickup", dest="pickup_report",
                   action="store_true",
                   help="Run the pickup reconciliation")
    parser.add_option("-d", "--delivery", dest="delivery_report",
                   action="store_true",
                   help="Run the delivery reconciliation")
    parser.add_option("-r", "--reports", dest="gen_reports",
                   action="store_true",
                   help="Generate logistic reconciliation reports")
    parser.add_option("-a", "--all", dest="all_reports",
                   action="store_true",
                   help="Run all reconciliations")
    parser.add_option("-P", "--provider", dest="provider",
                   default="BlueDart", type="string",
                   help="The PROVIDER this report is for",
                   metavar="PROVIDER")
    parser.set_defaults(pickup_report=False, delivery_report=False, gen_reports=False, all_reports=False)
    (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?")
    
    if options.all_reports:
        options.pickup_report = True
        options.delivery_report = True
    
    provider = get_provider_by_name(options.provider)
    
    if options.pickup_report:
        process_pickup_records(provider)
        process_dao_pickup_orders(provider)
        process_return_pickup_orders(provider)
    if options.delivery_report:
        process_local_connection_orders(provider)
        process_reached_destination_city_orders(provider)
        process_first_delivery_attempt_orders(provider)
        process_delivery_report(provider)
        create_crm_tickets_for_delivey_attempted_orders(provider)
        auto_close_crm_tickets_created()
    if options.gen_reports:
        generate_reports(provider)

if __name__ == '__main__':
    main()