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 shop2020.clients.CRMClient import CRMClient

from shop2020.clients.LogisticsClient import LogisticsClient

from shop2020.clients.TransactionClient import TransactionClient

from shop2020.clients.UserClient import UserClient

from LogisticUtils import enqueueMailForFDA

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, XML, fromstring

from datetime import datetime

import csv

import datetime

import optparse

import sys

import time

import traceback

import urllib2

from suds.client import Client

import json

import StringIO

import zlib

import gzip

import xmltodict

import ast

if __name__ == '__main__' and __package__ is None:

    import os

    sys.path.insert(0, os.getcwd())

RED_EXPRESS_URL = "http://tracking.getsetred.net/TrackingService.svc?wsdl"

username = 'C00086721141'

password = '87e95$'

tracking_Id_Type = 'REFERENCENO'

tracking_Level = 'ALL_DETAILS'

RED_EXPRESS_TRACKING_URL = 'http://webservices.getsetred.net/Services/BulkTracking.svc/'

headers = {

               "User-Agent" : "Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.218 Safari/535.1",

               "Accept" : "    text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8",

               "Accept-Language" : "en-us,en;q=0.5",

               "Accept-Encoding" : "gzip, deflate",

               "Connection" : "keep-alive",

               "Accept-Charset" : "ISO-8859-1",

               "Content-type": "application/json; charset=UTF-8"

               }

client = None

def getClient():

    global client

    if client is None:

        client = Client(RED_EXPRESS_URL, timeout=70)

    return client

defaultUndeliveredAsssigneeId = 47

from_user = 'cnc.center@shop2020.in'

from_pwd = '5h0p2o2o'

to = ['cnc.center@shop2020.in', "amit.sirohi@shop2020.in", "sandeep.sachdeva@shop2020.in", "sunil.kumar@shop2020.in", "rajveer.singh@shop2020.in"]

def get_updates(awb_number): 

    str = getClient().service.ProcessTrackingRequest('<TrackingRequest><Request><UserID>' + username + '</UserID><Password>' + password + '</Password><TrackingID>' + awb_number + '</TrackingID><TrackingLevel>ALL_DETAILS</TrackingLevel></Request></TrackingRequest>')

    print str

    return str

def get_updates_for_user(awb_number):

    root =  fromstring(str(get_updates(awb_number)))

    children = root.getchildren()

    results = []

    for child in children:

        nodes = child.findall('ShipmentInfo/ShipmentEvent')

        for element in reversed(nodes):

            datestring = element.findtext('Date', '')

            timestring = element.findtext('Time', '')

            description = element.findtext('ServiceEvent', '')

            results.append(datestring+"~!~"+timestring+"~!~"+description)

    return results

def get_track_updates(awb_numbers):

    track_data_list=[]

    if len(awb_numbers)>0:

        req_args = json.dumps({'password':password,

                               'trackingIdType':'REFERENCENO',

                               'trackingLevel':'ALL_DETAILS',

                               'userId':username,

                               'waybillNo': awb_numbers 

                               })

        request = urllib2.Request(RED_EXPRESS_TRACKING_URL, req_args, headers)

        response = urllib2.urlopen(request)

        encoding = response.info().get("Content-Encoding")    

        if encoding in ('gzip', 'x-gzip', 'deflate'):

            content = response.read()

            if encoding == 'deflate':

                track_data_decoded = StringIO.StringIO(zlib.decompress(content))

            else:

                track_data_decoded = gzip.GzipFile('', 'rb', 9, StringIO.StringIO(content))

        track_data_readable = track_data_decoded.read()

        conv_dict = xmltodict.parse(track_data_readable)

        track_data_json= json.dumps(conv_dict)

        if track_data_json.find('null') > 0:

            track_data_json = track_data_json.replace('null','\"No Description Available\"');

        track_data_dict = ast.literal_eval(track_data_json)

        if len(awb_numbers)==1:

            track_data_list=[]

            track_data_list.append(track_data_dict['BulkTrackingResponse']['BulkResponse']['TrackingResponse'])

            track_data_list.append('DUMMY')

        else:

            track_data_list = track_data_dict['BulkTrackingResponse']['BulkResponse']['TrackingResponse']    

    return track_data_list

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_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_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_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])

        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/RedExpress_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/RedExpress_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/RedExpress_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/RedExpress_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 = {}

    awb_number_list =[]

    for order in orders_tobe_picked_up:

        awb_number_list.append(order.airwaybill_no)

    track_update_list = get_track_updates(awb_number_list)

    for update in track_update_list:

        if update == 'DUMMY':

            continue

        else:

            try:

                airwaybill_no = update['ReferenceNo'] 

                track_list = update['TrackingList']['TrackingList']

                #track_list.reverse()

                for track_update in track_list:

                    if track_update['TrackingCode'] == 'BKD' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        delivery_date = datestring +' '+ timestring

                        picked_up_orders[airwaybill_no] = delivery_date

                        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 = {}

    awb_number_list =[]

    for order in orders_tobe_local_connected:

        awb_number_list.append(order.airwaybill_no)

    track_update_list = get_track_updates(awb_number_list)

    for update in track_update_list:

        if update == 'DUMMY':

            continue

        else:

            try:

                airwaybill_no = update['ReferenceNo'] 

                track_list = update['TrackingList']['TrackingList']

                #track_list.reverse()

                for track_update in track_list:

                    if track_update['TrackingCode'] == 'PRO' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        delivery_date = datestring +' '+ timestring

                        local_connected_orders[airwaybill_no] = delivery_date

                        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 = {}

    awb_number_list =[]

    for order in orders_tobe_reached_destination_city:

        awb_number_list.append(order.airwaybill_no)

    track_update_list = get_track_updates(awb_number_list)

    for update in track_update_list:

        if update == 'DUMMY':

            continue

        else:

            try:

                airwaybill_no = update['ReferenceNo'] 

                track_list = update['TrackingList']['TrackingList']

                #track_list.reverse()

                for track_update in track_list:

                    if track_update['TrackingCode'] == 'RDB' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        delivery_date = datestring +' '+ timestring

                        destination_city_reached_orders[airwaybill_no] = delivery_date

                        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 = {}

    awb_number_list =[]

    for order in orders_tobe_first_delivery_attempted:

        awb_number_list.append(order.airwaybill_no)

    track_update_list = get_track_updates(awb_number_list)

    for update in track_update_list:

        if update == 'DUMMY':

            continue

        else:

            try:

                airwaybill_no = update['ReferenceNo'] 

                track_list = update['TrackingList']['TrackingList']

                #track_list.reverse()

                for track_update in track_list:

                    if track_update['TrackingCode'] == 'OFD' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        delivery_date = datestring +' '+ timestring

                        first_atdl_orders[airwaybill_no] = delivery_date +'|'+ track_update['ServiceEvent']

                        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 = {}

    awb_order_map = {}

    for order in orders_tobe_delivered:

        awb_order_list =[]

        awb_order_list.append(order.id)

        awb_order_list.append(order.shipping_timestamp)

        awb_order_map[order.airwaybill_no]= awb_order_list

    track_update_list = get_track_updates(awb_order_map.keys())

    for update in track_update_list:

        if update == 'DUMMY':

            continue

        else:

            try:

                airwaybill_no = update['ReferenceNo'] 

                track_list = update['TrackingList']['TrackingList']

                #track_list.reverse()

                reason_for_return = None

                for record in track_list:

                    if record['TrackingCode'] == 'UDLD' :

                        reason_for_return = record['ServiceEvent'].split(" -")[1]

                        break

                for track_update in track_list:

                    if track_update['TrackingCode'] == 'DLVD' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        del_date = datestring +' '+ timestring

                        delivery_date = datetime.datetime.strptime(del_date,"%Y-%m-%d %H:%M:%S")

                        receiver = track_update['ServiceEvent'].split("[ ")[1].split(" ]")[0]

                        if to_py_date(awb_order_map.get(airwaybill_no)[1]) > delivery_date:

                            mail(from_user, from_pwd, to, "Delivery Problem for Red Express", "Order id " + str(awb_order_map.get(airwaybill_no)[0]) + " has shipping date " + str(awb_order_map.get(airwaybill_no)[1]) + " larger than delivery date " + str(delivery_date))

                        else:

                            delivered_orders[airwaybill_no] = str(delivery_date) + "|" +  receiver

                        break

                    elif track_update['TrackingCode'] == 'RTO' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        del_date = datestring +' '+ timestring

                        delivery_date = datetime.datetime.strptime(del_date,"%Y-%m-%d %H:%M:%S")

                        if reason_for_return == None:

                            returned_orders[airwaybill_no] = str(delivery_date) + "|"  + " Order Booked for Return"

                        else:

                            returned_orders[airwaybill_no] = str(delivery_date) + "|"  + reason_for_return

                        break

                    elif track_update['TrackingCode'] == 'UDLD' :

                        date_obj = datetime.datetime.strptime(track_update['ExecutionDate'].split(' ')[0],"%m/%d/%Y")

                        datestring  = date_obj.strftime("%Y-%m-%d")

                        timestring = track_update['ExecutionTime']+':00'

                        del_date = datestring +' '+ timestring

                        delivery_date = datetime.datetime.strptime(del_date,"%Y-%m-%d %H:%M:%S")

                        if reason_for_return == None:

                            undelivered_orders[airwaybill_no] = str(delivery_date) + "|" + track_update['ServiceEvent'].split(" -")[1]

                        else:

                            undelivered_orders[airwaybill_no] = str(delivery_date) + "|" + reason_for_return

                        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 create_crm_tickets_for_delivey_attempted_orders(provider):

    try:

        tickets_tobe_created = fetch_data(provider.id, [OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE])

        userClient = UserClient().get_client()

        crmServiceClient = CRMClient().get_client()

        for order in tickets_tobe_created:

            ticket_created = False

            searchFilter = SearchFilter()

            user = userClient.getUserByEmail(order.customer_email)

            if user is None or user.userId == -1:

                searchFilter.customerEmailId = order.customer_email

                searchFilter.customerMobileNumber = order.customer_mobilenumber

            else:

                searchFilter.customerId = user.userId

            searchFilter.ticketCategory = TicketCategory.UNDELIVERED

            tickets = crmServiceClient.getTickets(searchFilter)

            print tickets

            for old_ticket in tickets:

                if old_ticket.orderId == order.id:

                    ticket_created = True

                    break

            if not ticket_created:

                print "creating ticket for orderId:"+str(order.id)

                ticket = Ticket()

                activity = Activity()

                description = order.statusDescription + "\n\nOrder not delivered by courier due to problems at customer end."

                ticket.creatorId = 1

                ticket.assigneeId = defaultUndeliveredAsssigneeId

                ticket.category = TicketCategory.UNDELIVERED

                ticket.priority = TicketPriority.HIGH

                ticket.status = TicketStatus.OPEN

                ticket.description = description

                ticket.orderId = order.id

                ticket.airwayBillNo = order.airwaybill_no

                activity.creatorId = 1

                activity.ticketAssigneeId = ticket.assigneeId

                activity.type = ActivityType.OTHER

                activity.description = description

                activity.ticketCategory = ticket.category

                activity.ticketDescription = ticket.description

                activity.ticketPriority = ticket.priority

                activity.ticketStatus = ticket.status

                if user is None or user.userId == -1:

                    ticket.customerEmailId = order.customer_email

                    ticket.customerMobileNumber = order.customer_mobilenumber

                    ticket.customerName = order.customer_name

                    activity.customerEmailId = order.customer_email

                    activity.customerMobileNumber = order.customer_mobilenumber

                    activity.customerName = order.customer_name

                else:

                    ticket.customerId = user.userId

                    activity.customerId = user.userId

                crmServiceClient.insertTicket(ticket, activity)

                '''

                Inform user about first delivery attempt

                '''

                enqueueMailForFDA(order)

    except:

        print "Some issue while creating crm tickets for orders in FIRST_DELIVERY_ATTEMPT_MADE status"

        traceback.print_exc()

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]:

                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 = "%A,%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[0:8]

    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="RedExpress", 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()