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, AwbUpdate, Provider, \

     DeliveryEstimate, WarehouseAllocation, \

    PublicHolidays, ServiceableLocationDetails

from shop2020.thriftpy.logistics.ttypes import LogisticsServiceException,\

    DeliveryType

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

from elixir import session

import datetime, time

import sys

warehouse_allocation_cache = {}

serviceable_location_cache = {}

delivery_estimate_cache = {}

'''

This class is for only data transfer. Never used outside this module.

'''

class _DeliveryEstimateObject:

    def __init__(self, delivery_time, reliability, provider_id, warehouse_location):

        self.delivery_time = delivery_time

        self.reliability = reliability

        self.provider_id = provider_id

        self.warehouse_location = warehouse_location 

def initialize(dbname="logistics", db_hostname="localhost"):

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

    DataService.initialize(dbname, db_hostname)

    print "Starting cache population at: " + str(datetime.datetime.now())

    __cache_warehouse_allocation_table()

    __cache_serviceable_location_details_table()

    __cache_delivery_estimate_table()

    close_session()

    print "Done cache population at: " + str(datetime.datetime.now())

def __cache_delivery_estimate_table():

    delivery_estimates = DeliveryEstimate.query.all()

    for delivery_estimate in delivery_estimates:

        delivery_estimate_cache[delivery_estimate.destination_pin, delivery_estimate.provider_id, delivery_estimate.warehouse_location]\

        =delivery_estimate.delivery_time, delivery_estimate.reliability

def __cache_serviceable_location_details_table():

    serviceable_locations = ServiceableLocationDetails.query.all()

    for serviceable_location in serviceable_locations:

        try:

            provider_pincodes = serviceable_location_cache[serviceable_location.provider_id]

        except:

            provider_pincodes = {}

            serviceable_location_cache[serviceable_location.provider_id] = provider_pincodes 

        provider_pincodes[serviceable_location.dest_pincode] = serviceable_location.dest_code, serviceable_location.exp, serviceable_location.cod, serviceable_location.station_type 

def __cache_warehouse_allocation_table():

    warehouse_allocations = WarehouseAllocation.query.all()

    for warehouse_allocation in warehouse_allocations:

        warehouse_allocation_cache[warehouse_allocation.pincode]=warehouse_allocation.primary_warehouse_location

def get_provider(provider_id):

    provider =  Provider.get_by(id=provider_id)

    return provider

def get_providers():

    providers = Provider.query.all()

    return providers 

def is_cod_allowed(destination_pin):

    cod = False

    try:

        for value in serviceable_location_cache.itervalues():

            cod = cod or value[destination_pin][2]

    except Exception as ex:

        print "Unexpected error:", sys.exc_info()[0]

    return cod

def get_logistics_estimation(destination_pin, item_selling_price, warehouse_location=None, type=DeliveryType.PREPAID):

    if warehouse_location is None:

        try:

            warehouse_location = warehouse_allocation_cache[destination_pin]

        except:

            print "Unexpected error:", sys.exc_info()[0]

            raise LogisticsServiceException(101, "No Warehouse locations assigned to this pincode: " + destination_pin)

    provider_id = __get_logistics_provider_for_destination_pincode(type, destination_pin)

    if not provider_id:

        raise LogisticsServiceException(101, "No provider assigned for pincode: " + str(destination_pin) + \

                                        ", and warehouse location: " + str(warehouse_location))

#    query_provider = DestinationProviderAllocation.query.filter_by(destination_pin = destination_pin)

#    query_provider = query_provider.filter_by(warehouse_location = warehouse_location)

#    try:

#        if (item_selling_price <= 5000):

#            provider = query_provider.one().provider_less_amount

#        else:

#            provider = query_provider.one().provider_more_amount

#    except Exception as ex:

#        print ex

#        print "Unexpected error:", sys.exc_info()[0]

#        raise LogisticsServiceException(101, "No provider assigned for pincode: " + str(destination_pin) + \

#                                        ", and warehouse location: " + str(warehouse_location))

    try:

        delivery_time = delivery_estimate_cache[destination_pin, provider_id, warehouse_location][0]

        reliability = delivery_estimate_cache[destination_pin, provider_id, warehouse_location][1]

        delivery_estimate = _DeliveryEstimateObject(delivery_time, reliability, provider_id, warehouse_location)

        return delivery_estimate

    except Exception as ex:

        print ex

        raise LogisticsServiceException(103, "No Logistics partner listed for this destination pincode and the primary warehouse")

def __get_logistics_provider_for_destination_pincode(type, destination_pin):

    for provider_id, value in serviceable_location_cache.iteritems():

        try:

            dest_code, exp, cod, station_type = value[destination_pin]

        except:

            print "Unexpected error:", sys.exc_info()[0]

            continue

        if type == DeliveryType.PREPAID and exp:

            return provider_id

        if type == DeliveryType.COD and cod:

            return provider_id

    return None

def add_empty_AWBs(numbers, provider_id, type):

    for number in numbers:

        query = Awb.query.filter_by(awb_number = number, provider_id = provider_id)

        try:

            query.one()

        except:    

            awb = Awb()

            awb.awb_number = number

            awb.provider_id = provider_id

            awb.is_available = True

            awb.type = type

    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, type = DeliveryType.PREPAID):

    query = Awb.query.with_lockmode("update").filter_by(provider_id = provider_id, is_available = True)  #check the provider thing

    if type == DeliveryType.PREPAID:

        query = query.filter_by(type="Prepaid")

    if type == DeliveryType.COD:

        query = query.filter_by(type="COD")

    try:

        awb = query.first()

        awb.is_available = False

        session.commit()

        return awb.awb_number

    except:

        raise LogisticsServiceException(103, "Unable to get an AWB for the given Provider: " + str(provider_id))

def get_free_awb_count(provider_id, type):

    count = Awb.query.filter_by(provider_id = provider_id, is_available = True, type=type).count()

    if count == None:

        count = 0

    return count

def get_shipment_info(awb_number, provider_id):

    awb = Awb.get_by(awb_number = awb_number, provider_id = provider_id)

    query = AwbUpdate.query.filter_by(awb = awb)

    info = query.all()

    return info

def get_holidays(start_date, end_date):

    query = PublicHolidays.query

    if start_date != -1:

        query = query.filter(PublicHolidays.date >= to_py_date(start_date))

    if end_date != -1:

        query = query.filter(PublicHolidays.date <= to_py_date(end_date))

    holidays = query.all()

    holiday_dates = [to_java_date(datetime.datetime(*time.strptime(str(holiday.date), '%Y-%m-%d')[:3])) for holiday in holidays] 

    return holiday_dates

def close_session():

    if session.is_active:

        print "session is active. closing it."

        session.close()