Subversion Repositories SmartDukaan

'''

Created on 13-Sep-2010

@author: rajveer

'''

from shop2020.logistics.service.impl import DataService

from shop2020.logistics.service.impl.DataService import AWB, Provider, Shipment,\

    ShipmentUpdate, DeliveryEstimate, PincodeWarehouseMapping

from shop2020.thriftpy.logistics.ttypes import LogisticsServiceException

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

from elixir import session

import datetime

def initialize():

    log_entry("initialize@DataAccessor", "Initializing data service")

    DataService.initialize()

def get_logistics_info(destination_pincode, sku_id):

    query = PincodeWarehouseMapping.query.filter_by(pincode = destination_pincode)

    try:

        mapping = query.one()

    except:

        raise LogisticsServiceException(101, "no warehouse assigned to pincode")

    warehouse_id = mapping.warehouse_id

    warehouse_pincode = mapping.warehouse_pin

    query = DeliveryEstimate.query.filter_by(source_pin = warehouse_pincode)

    query = query.filter_by(destination_pin = destination_pincode)

    try: 

        delivery_estimate = query.one()

    except:

        raise LogisticsServiceException(102, "no provider to deliver to destination pincode")

    provider_id = delivery_estimate.provider_id

    airway_billno = get_empty_AWB(provider_id)

    query = query.filter_by(provider_id = provider_id)

    return warehouse_id, provider_id, airway_billno, delivery_estimate.delivery_time 

def get_provider_by_id(provider_id):

    query = Provider.query.filter_by(id=provider_id)

    try:

        return query.one()

    except:

        provider = Provider()

        provider.name = "Default"

        session.commit()

        return provider

def add_empty_AWBs(numbers, provider_id):

    provider = get_provider_by_id(provider_id)

    for number in numbers:

        query = AWB.query.filter(AWB.awb_number == number)

        query = query.filter(AWB.provider_id == provider_id)

        try:

            query.one()

        except:    

            awb = AWB()

            awb.awb_number = number

            awb.provider = provider

            awb.is_available = True

    session.commit()    

def set_AWB_as_used(awb_number):

    query = AWB.query.filter_by(awb_number = awb_number)

    awb = query.one() 

    awb.is_available=False

    session.commit()

def get_empty_AWB(provider_id):

    query = AWB.query.filter_by(provider_id = provider_id)  #check the provider thing

    query = query.filter_by(is_available=True)

    try:

        awbs = query.all()

        awb = awbs[0]

        set_AWB_as_used(awb.awb_number)

        return awb.awb_number

    except:

        return "129102" #generate new exception

def get_providers():

    return Provider.query.all()

def get_provider(provider_id):

        return Provider.get_by(id=provider_id)

def get_shipment_info(awb_number):

    shipment = Shipment.get_by(awb = awb_number)

    query = ShipmentUpdate.query.filter_by(shipment = shipment)

    return query.all()

def create_shipment(shipment): #add date for the shipment

    new_shipment = Shipment()

    new_shipment.destination = shipment.destination 

    new_shipment.origin = shipment.origin

    new_shipment.recepient_address = shipment.recepient_address

    new_shipment.recepient_name = shipment.recepient_name

    new_shipment.recepient_phone = shipment.recepient_phone

    new_shipment.recepient_pincode = shipment.recepient_pincode

    new_shipment.shipment_contents = shipment.shipment_contents

    new_shipment.shipment_weight = shipment.shipment_weight

    new_shipment.warehouse_name = shipment.warehouse_name

    #new_shipment.timestamp = shipment.timestamp 

    if shipment.timestamp is None: 

        new_shipment.timestamp = datetime.datetime.today()

    else:

        new_shipment.timestamp = shipment.timestamp

    new_shipment.awb = shipment.awb

    session.commit() 

    return

def update_shipment_status(awb, shipment_update):

    shipment = Shipment.get_by(awb = awb)

    new_shipment_update = ShipmentUpdate()

    new_shipment_update.shipment = shipment

    new_shipment_update.description = shipment_update.description

    new_shipment_update.pin = shipment_update.pin

    new_shipment_update.shipment 

    if shipment_update.timestamp is None:

        new_shipment_update.timestamp = datetime.datetime.today()

    else:

        new_shipment_update.timestamp = shipment_update.timestamp    

    session.commit()

def get_shipments(warehouse_id, from_date, to_date, provider_id):

    awbs = AWB.query.filter_by(provider_id = provider_id).all()

    shipments = []

    for awb in awbs:

        awb_number = awb.awb_number

        query =  Shipment.query.filter(Shipment.awb == awb_number)

        query = query.filter(Shipment.timestamp > from_date)

        query = query.filter(Shipment.timestamp < to_date)

        try:

            shipment = query.one()

            shipments.append(shipment)

        except:

            continue    

    return shipments

def get_todays_shipments(warehouse_id, provider_id):

    from_date = datetime.date.today()

    from_datetime = datetime.datetime(from_date.year, from_date.month, from_date.day)

    to_date = from_date + datetime.timedelta(days=1)

    to_datetime = datetime.datetime(to_date.year, to_date.month, to_date.day)

    return get_shipments(warehouse_id, from_datetime, to_datetime, provider_id)

def get_logistics_estimation(item_id, destination_pin, provider_id):

    query = PincodeWarehouseMapping.query.filter_by(pincode = destination_pin)

    try:

        warehouse = query.one()

    except:

        warehouse = None

        #need to throw exception

    warehouse_pin = warehouse.warehouse_pin

    query = DeliveryEstimate.query.filter_by(source_pin = warehouse_pin)

    query = query.filter_by(destination_pin = destination_pin)

    query = query.filter_by(provider_id = provider_id)

    try:

        return query.one(), warehouse.warehouse_id

    except:

        return None

    # need to check the availability in another service before returning estimation.

def add_delivery_estimate(warehouse_id, destination_pin, provider_id, delivery_time, reliability):

    query = Provider.query.filter_by(id=provider_id)

    try:

        provider = query.one()

    except:

        print "provider not found"

    query = PincodeWarehouseMapping.query.filter_by(warehouse_id = warehouse_id)

    try:

        warehouse = query.one()

        warehouse_pin = warehouse.warehouse_pin

    except:

        warehouse_pin = 0

        print "warehouse pin not found"

    delivery_estimate = DeliveryEstimate()

    delivery_estimate.source_pin = warehouse_pin

    delivery_estimate.destination_pin = destination_pin

    delivery_estimate.provider = provider

    delivery_estimate.delivery_time = delivery_time

    delivery_estimate.relibility = reliability

    session.commit()

def add_pincode_warehouse_mapping(pincode, warehouse_id, warehouse_pin):

    mapper = PincodeWarehouseMapping()

    mapper.pincode = pincode

    mapper.warehouse_id = warehouse_id

    if warehouse_pin:

        mapper.warehouse_name = warehouse_pin

    session.commit()