Subversion Repositories SmartDukaan

'''

Created on 29-Jul-2011

@author: Chandranshu

'''

from elixir import metadata, setup_all, session

from shop2020.clients.CatalogClient import CatalogClient

from shop2020.clients.TransactionClient import TransactionClient

from shop2020.purchase.main.model.LineItem import LineItem

from shop2020.purchase.main.model.Purchase import Purchase

from shop2020.purchase.main.model.PurchaseOrder import PurchaseOrder

from shop2020.purchase.main.model.RevisionedPurchaseOrder import RevisionedPurchaseOrder

from shop2020.purchase.main.model.Supplier import Supplier

from shop2020.thriftpy.model.v1.order.ttypes import OrderStatus

from shop2020.thriftpy.purchase.ttypes import PurchaseServiceException, POStatus, \

    PurchaseOrder as TPurchaseOrder, LineItem as TLineItem

from sqlalchemy import create_engine

import datetime

import logging

import sys

logging.basicConfig(level=logging.DEBUG)

class PurchaseServiceHandler:

    '''

    classdocs

    '''

    def __init__(self, dbname='warehouse', db_hostname='localhost',  echoOn=True):

        '''

        Constructor

        '''

        engine = create_engine('mysql://root:shop2020@' + db_hostname + '/' + dbname, pool_recycle=7200)

        metadata.bind = engine

        metadata.bind.echo = echoOn

        setup_all(True)

    def createPurchaseOrder(self, tPurchaseOrder):

        """

        Creates a purchase order based on the data in the given purchase order object.

        This method populates a number of missing fields

        Parameters:

         - purchaseOrder

        """

        try:

            purchaseOrder = PurchaseOrder(tPurchaseOrder)

            session.commit()

            purchaseOrder.set_po_number()

            session.commit()

            return purchaseOrder.id

        finally:

            self.close_session()

    def getAllPurchaseOrders(self, status):

        """

        Returns a list of all the purchase orders in the given state

        Parameters:

         - status

        """

        try:

            pos = PurchaseOrder.query.filter_by(status=status).all()

            return [po.to_thrift_object() for po in pos ]

        finally:

            self.close_session()

    def getPurchaseOrder(self, id):

        """

        Returns the purchase order with the given id. Throws an exception if there is no such purchase order.

        Parameters:

         - id

        """

        try:

            purchaseOrder = PurchaseOrder.get_by(id=id)

            if not purchaseOrder:

                raise PurchaseServiceException(101, "No purchase order can be found with id:" + str(id)) 

            return purchaseOrder.to_thrift_object()

        finally:

            self.close_session()

    def getSupplier(self, id):

        """

        Returns the supplier with the given order id. Throws an exception if there is no such supplier.

        Parameters:

         - id

        """

        try:

            return Supplier.get_by(id=id).to_thrift_object()

        finally:

            self.close_session()

    def startPurchase(self, purchaseOrderId, invoiceNumber, freightCharges):

        """

        Creates a purchase for the given purchase order.

        Throws an exception if no more purchases are allowed against the given purchase order.

        Parameters:

         - purchaseOrderId

         - invoiceNumber

         - freightCharges

        """

        try:

            purchase_order = PurchaseOrder.get_by(id = purchaseOrderId)

            purchase = Purchase(purchase_order, invoiceNumber, freightCharges)

            session.commit()

            return purchase.id

        finally:

            self.close_session()

    def closePurchase(self, purchaseId):

        """

        Marks a purchase as complete and updates the receivedOn time.

        Throws an exception if no such purchase exists.

        Parameters:

         - purchaseId

        """

        try:

            purchase = Purchase.get_by(id=purchaseId)

            purchase.receivedOn = datetime.datetime.now()

            session.commit()

        finally:

            self.close_session()

    def getAllPurchases(self, purchaseOrderId, open):

        """

        Returns all open or closed purchases for the given purchase order. Throws an exception if no such purchase order exists

        Parameters:

         - purchaseOrderId

         - open

        """

        try:

            if open:

                purchases = Purchase.query.filter_by(purchaseOrder_id = purchaseOrderId, receivedOn = None).all()

            else:

                purchases = Purchase.query.filter_by(purchaseOrder_id = purchaseOrderId).filter(receivedOn != None).all()

            return [purchase.to_thrift_object() for purchase in purchases]

        finally:

            self.close_session()

    def getPurchaseOrderForPurchase(self, purchaseId):

        """

        Returns the purchase order for a given purchase

        Parameters:

         - purchaseId

        """

        try:

            return self.getPurchaseOrder(Purchase.query.filter_by(id = purchaseId).one().purchaseOrder_id)

        finally:

            self.close_session()

    def getPendingPurchaseOrders(self, warehouseId):

        """

        Creates purchase order objects from pending orders

        Parameters:

         - warehouseId

        """

        try:

            purchaseOrders = []

            if not warehouseId:

                raise PurchaseServiceException(101, "bad warehouse id")

            transactionClient = TransactionClient().get_client()

            pending_orders = transactionClient.getOrdersInBatch([OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW, OrderStatus.ACCEPTED], 0, 0, warehouseId)

            if not pending_orders:

                return purchaseOrders

            catalog_client = CatalogClient().get_client()

            availability = {}

            for item in catalog_client.getAllItemsForWarehouse(warehouseId):

                availability[item.id] = [item.itemInventory.availability[warehouseId], item]

            codRequirements = {}

            requirements = {}

            for order in pending_orders:

                if order.purchaseOrderId:

                    continue

                for lineitem in order.lineitems:

                    if (requirements.has_key(lineitem.item_id)):

                        requirements[lineitem.item_id] += lineitem.quantity

                    else:

                        requirements[lineitem.item_id] = lineitem.quantity

                    if order.cod:

                        if (codRequirements.has_key(lineitem.item_id)):

                            codRequirements[lineitem.item_id] += lineitem.quantity

                        else:

                            codRequirements[lineitem.item_id] = lineitem.quantity

            netRequirements = {}

            for itemId in requirements.keys():

                requirementsCount = requirements.get(itemId)

                if  availability.has_key(itemId):

                    availabilityCount = availability.get(itemId)[0]

                    item              = availability.get(itemId)[1]

                    if item.preferredVendor is None or item.preferredVendor == 1:

                        continue

                    if requirementsCount > availabilityCount:

                        if (netRequirements.has_key(item.preferredVendor)):

                            netRequirements[item.preferredVendor].append([item, requirementsCount - availabilityCount])

                        else:

                            netRequirements[item.preferredVendor] = [[item, requirementsCount - availabilityCount]];

                else:

                    item = catalog_client.getItem(itemId);

                    if item.preferredVendor is None:

                        raise PurchaseServiceException(101, 'Preferred Vendor missing for ' + " ".join([item.brand, item.modelName, item.modelNumber, item.color]))

                    if item.preferredVendor == 1:

                        raise PurchaseServiceException(101, 'Preferred Vendor set to HotSpot for ' + " ".join([item.brand, item.modelName, item.modelNumber, item.color]))

                    if (netRequirements.has_key(item.preferredVendor)):

                        netRequirements[item.preferredVendor].append([item, requirementsCount])

                    else:

                        netRequirements[item.preferredVendor] = [[item, requirementsCount]];

            if not netRequirements:

                return purchaseOrders

            for vendorId in netRequirements.keys():

                t_purchase_order = TPurchaseOrder()

                t_purchase_order.supplierId = vendorId

                t_purchase_order.warehouseId = warehouseId

                t_purchase_order.lineitems = []

                for key in netRequirements.get(vendorId):

                    item     = key[0]

                    quantity = key[1]

                    t_po_lineitem = TLineItem()

                    t_po_lineitem.productGroup = item.productGroup

                    t_po_lineitem.brand = item.brand

                    t_po_lineitem.modelNumber = item.modelNumber

                    t_po_lineitem.modelName = item.modelName

                    t_po_lineitem.color = item.color

                    t_po_lineitem.itemId = item.id

                    t_po_lineitem.quantity = quantity

                    if codRequirements.has_key(item.id):

                        t_po_lineitem.codCount = min(codRequirements[item.id], quantity)

                    try:

                        item_pricing = catalog_client.getItemPricing(item.id, vendorId)

                    except Exception as e:

                        vendor = self.getSupplier(vendorId)

                        print 'Could not find transfer price for Item id: ' + str(item.id) + ' and vendor id: ' + str(vendorId)

                        print e

                        raise PurchaseServiceException(101, 'Transfer price missing for ' + vendor.name + ' and ' + " ".join([item.brand, item.modelName, item.modelNumber, item.color]))

                    t_po_lineitem.unitPrice = item_pricing.transferPrice

                    t_purchase_order.lineitems.append(t_po_lineitem)

                purchaseOrders.append(t_purchase_order)

            return purchaseOrders

        finally:

            self.close_session()

    def getSuppliers(self, ):

        """

        Returns all the valid suppliers

        """

        try:

            return [Supplier.to_thrift_object(supplier) for supplier in Supplier.query.all()]

        finally:

            self.close_session()

    def fulfillPO(self, purchaseOrderId, itemId, quantity):

        """

        Fulfills a given purchase order with an item.

        Parameters:

         - purchaseOrderId

         - itemId

         - quantity

        """

        try:

            lineitems = LineItem.query.filter_by(purchaseOrder_id = purchaseOrderId, itemId = itemId).all()

            if lineitems:

                if lineitems[0].unfulfilledQuantity < quantity:

                    raise PurchaseServiceException(101, 'Can fulfill only ' + str(lineitems[0].unfulfilledQuantity) + 'quantity')

                else:

                    lineitems[0].unfulfilledQuantity -= quantity

                    if not lineitems[0].unfulfilledQuantity:

                        lineitems[0].fulfilled = 1

                        if not LineItem.query.filter_by(purchaseOrder_id = purchaseOrderId, fulfilled = 0).all():

                            purchaseOrder = self.getPurchaseOrder(purchaseOrderId)

                            purchaseOrder.status = POStatus.CLOSED

                    session.commit()

                    return

            raise PurchaseServiceException(101, 'No lineitem found with this itemId: ' + str(itemId) + ' in PO Id: ' + str(purchaseOrderId) )

        finally:

            self.close_session()

    def updatePurchaseOrder(self, purchaseOrder):

        """

        Amends a PO sa per the new lineitems passed

        Parameters:

         - purchaseOrder

        """

        try:

            existingPurchaseOrder = PurchaseOrder.get_by(id = purchaseOrder.id)

            maxRevision = 0

            existingRevisions = RevisionedPurchaseOrder.query.filter_by(purchaseOrderId = purchaseOrder.id).all()

            if existingRevisions:

                maxRevision = max([a.revision for a in existingRevisions]) + 1

            for lineitem in existingPurchaseOrder.lineitems:

                revisionedPurchaseOrder = RevisionedPurchaseOrder()

                revisionedPurchaseOrder.purchaseOrderId = purchaseOrder.id

                revisionedPurchaseOrder.revision = maxRevision

                revisionedPurchaseOrder.itemId = lineitem.itemId

                revisionedPurchaseOrder.unfulfilledQuantity = lineitem.unfulfilledQuantity

                revisionedPurchaseOrder.unitPrice = lineitem.unitPrice

                revisionedPurchaseOrder.createdAt = lineitem.createdAt

                revisionedPurchaseOrder.quantity = lineitem.quantity

                lineitem.delete()

            existingPurchaseOrder.lineitems = [LineItem(existingPurchaseOrder, t_lineitem) for t_lineitem in purchaseOrder.lineitems]

            existingPurchaseOrder.totalCost = sum([t_lineitem.quantity * t_lineitem.unitPrice for t_lineitem in purchaseOrder.lineitems])

            session.commit()

        finally:

            self.close_session()

    def close_session(self):

        if session.is_active:

            print "session is active. closing it."

            session.close()

    def isAlive(self, ):

        """

        For checking weather service is active alive or not. It also checks connectivity with database

        """

        try:

            session.query(Supplier.id).limit(1).all()

            return True

        except:

            return False

        finally:

            self.close_session()