WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/purchase/main/handler/PurchaseServiceHandler.py

 from shop2020.clients.InventoryClient import InventoryClient
 from shop2020.clients.TransactionClient import TransactionClient
 from shop2020.purchase.main.model.Invoice import Invoice
 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.PurchaseReturn import PurchaseReturn
 from shop2020.purchase.main.model.RevisionedPurchaseOrder import \
     RevisionedPurchaseOrder
 from shop2020.purchase.main.model.Supplier import Supplier
+from shop2020.purchase.main.model.PurchaseOrder import PurchaseOrder
 from shop2020.thriftpy.generic.ttypes import ExceptionType
 from shop2020.thriftpy.model.v1.inventory.ttypes import WarehouseType, \
     InventoryType
 from shop2020.thriftpy.model.v1.order.ttypes import OrderStatus
 from shop2020.thriftpy.purchase.ttypes import PurchaseServiceException, POStatus, \
         engine = create_engine('mysql://root:shop2020@' + db_hostname + '/' + dbname, pool_recycle=7200)
         metadata.bind = engine
         metadata.bind.echo = echoOn
         setup_all(True)
+    def getPOforOurExternalBilling(self):
+        todayDate = datetime.datetime.now()
+        todayDate = todayDate.replace(hour=0)
+        purchaseOrder = PurchaseOrder.query.filter(PurchaseOrder.supplierId == 1).filter(PurchaseOrder.createdAt > todayDate).first()
+        if purchaseOrder is None:
+            t_purchaseOrder = TPurchaseOrder()
+            t_purchaseOrder.supplierId = 1
+            t_purchaseOrder.createdAt = datetime.datetime.now()
+            t_purchaseOrder.status = 0
+            t_purchaseOrder.totalCost = 0
+            t_purchaseOrder.poNumber = 'Ours-Ext-' + str(todayDate.year) + "-" + str(todayDate.month) + "-" + str(todayDate.day)
+            purchaseOrder = PurchaseOrder(t_purchaseOrder)
+            session.commit()
+        return purchaseOrder.id
+    def updatelineItemforOursExternalBilling(self, poId, itemId, unitPrice):
+        lineItem = LineItem.get_by(purchaseOrder_id=poId, itemId=itemId)
+        if lineItem is None:
+            purchaseOrder = PurchaseOrder.get_by(id=poId)
+            t_lineItem = TLineItem()
+            t_lineItem.itemId = itemId
+            t_lineItem.quantity = 1
+            t_lineItem.unfulfilledQuantity = 1
+            t_lineItem.createdAt = datetime.datetime.now()
+            t_lineItem.unitPrice = unitPrice
+            t_lineItem.fulfilled = False
+            lineItem = LineItem(purchaseOrder, t_lineItem)
+        else:
+            lineItem.quantity = lineItem.quantity + 1
+            lineItem.fulfilled = False
+            lineItem.unfulfilledQuantity = lineItem.unfulfilledQuantity + 1
+        session.commit()
+    def receiveinvoiceforOursExternalBilling(self, invoiceNumber):
+        invoice = Invoice()
+        invoice.invoiceNumber = invoiceNumber
+        invoice.date = datetime.datetime.now()
+        invoice.numItems = 1
+        invoice.receivedFrom = "Hotspot-Billing"
+        invoice.supplierId = 1
+        session.commit()
+    def createPurchaseforOursExternalBilling(self, poId, invoiceNumber):
+        purchaseOrder = PurchaseOrder.get_by(id=poId)
+        purchase = Purchase(purchaseOrder, invoiceNumber, 0)
+        session.commit()
+        return purchase.id
     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
          - purchaseOrderId
          - invoiceNumber
          - freightCharges
         """
         try:
-            purchase_order = PurchaseOrder.get_by(id = purchaseOrderId)
+            purchase_order = PurchaseOrder.get_by(id=purchaseOrderId)
             purchase = Purchase(purchase_order, invoiceNumber, freightCharges)
             session.commit()
             return purchase.id
         finally:
             self.close_session()
          - purchaseOrderId
          - open
         """
         try:
             if open:
-                purchases = Purchase.query.filter_by(purchaseOrder_id = purchaseOrderId, receivedOn = None).all()
+                purchases = Purchase.query.filter_by(purchaseOrder_id=purchaseOrderId, receivedOn=None).all()
             else:
-                purchases = Purchase.query.filter_by(purchaseOrder_id = purchaseOrderId).filter(Purchase.receivedOn != None).all()
+                purchases = Purchase.query.filter_by(purchaseOrder_id=purchaseOrderId).filter(Purchase.receivedOn != None).all()
             return [purchase.to_thrift_object() for purchase in purchases]
         finally:
             self.close_session()
         Parameters:
          - purchaseOrderId
          - open
         """
         try:
-            purchases = Purchase.query.filter_by(purchaseOrder_id = purchaseOrderId).all()
+            purchases = Purchase.query.filter_by(purchaseOrder_id=purchaseOrderId).all()
             return [purchase.to_thrift_object() for purchase in purchases]
         finally:
             self.close_session()
         Parameters:
          - purchaseId
         """
         try:
-            return self.getPurchaseOrder(Purchase.query.filter_by(id = purchaseId).one().purchaseOrder_id)
+            return self.getPurchaseOrder(Purchase.query.filter_by(id=purchaseId).one().purchaseOrder_id)
         finally:
             self.close_session()
     def getPendingPurchaseOrders(self, warehouseId):
         """
             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]
+                    item = availability.get(itemId)[1]
                     if requirementsCount > availabilityCount:
                         if item.preferredVendor is None:
                             raise PurchaseServiceException(101, 'Preferred Vendor missing for ' + " ".join([str(item.brand), str(item.modelName), str(item.modelNumber), str(item.color)]))
                         if (netRequirements.has_key(item.preferredVendor)):
                             netRequirements[item.preferredVendor].append([item, requirementsCount - availabilityCount])
                 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]
+                    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
                 purchaseOrders.append(t_purchase_order)
             return purchaseOrders
         finally:
             self.close_session()
-    def getSuppliers(self, ):
+    def getSuppliers(self,):
         """
         Returns all the valid suppliers
         """
         try:
             return [Supplier.to_thrift_object(supplier) for supplier in Supplier.query.all()]
          - purchaseId
          - itemId
          - quantity
         """
         try:
-            purchaseOrderId = Purchase.query.filter_by(id = purchaseId).one().purchaseOrder_id
+            purchaseOrderId = Purchase.query.filter_by(id=purchaseId).one().purchaseOrder_id
-            lineitems = LineItem.query.filter_by(purchaseOrder_id = purchaseOrderId, itemId = itemId).all()
+            lineitems = LineItem.query.filter_by(purchaseOrder_id=purchaseOrderId, itemId=itemId).all()
             if lineitems:
                 fulfilledQuantity = lineitems[0].quantity - lineitems[0].unfulfilledQuantity
                 if fulfilledQuantity < quantity:
                     raise PurchaseServiceException(101, 'Can UnFulfill only ' + str(fulfilledQuantity) + 'quantity')
                 else:
          - purchaseOrderId
          - itemId
          - quantity
         """
         try:
-            lineitems = LineItem.query.filter_by(purchaseOrder_id = purchaseOrderId, itemId = itemId).all()
+            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 = lineitems[0].unfulfilledQuantity - quantity
                     if not lineitems[0].unfulfilledQuantity:
                         lineitems[0].fulfilled = 1
                         session.commit()
-                        if not LineItem.query.filter_by(purchaseOrder_id = purchaseOrderId, fulfilled = 0).all():
+                        if not LineItem.query.filter_by(purchaseOrder_id=purchaseOrderId, fulfilled=0).all():
                             purchaseOrder = PurchaseOrder.get_by(id=purchaseOrderId)
                             purchaseOrder.status = POStatus.CLOSED
                     session.commit()
                     return
-            raise PurchaseServiceException(101, 'No lineitem found with this itemId: ' + str(itemId) + ' in PO Id: ' + str(purchaseOrderId) )
+            raise PurchaseServiceException(101, 'No lineitem found with this itemId: ' + str(itemId) + ' in PO Id: ' + str(purchaseOrderId))
         finally:
             self.close_session()
     def updatePurchaseOrder(self, purchaseOrder):
         """
         Parameters:
          - purchaseOrder
         """
         try:
-            existingPurchaseOrder = PurchaseOrder.get_by(id = purchaseOrder.id)
+            existingPurchaseOrder = PurchaseOrder.get_by(id=purchaseOrder.id)
             maxRevision = 0
-            existingRevisions = RevisionedPurchaseOrder.query.filter_by(purchaseOrderId = purchaseOrder.id).all()
+            existingRevisions = RevisionedPurchaseOrder.query.filter_by(purchaseOrderId=purchaseOrder.id).all()
             if existingRevisions:
                 maxRevision = max([a.revision for a in existingRevisions]) + 1
             newPOItems = {}
             for t_lineitem in purchaseOrder.lineitems:
         Parameters:
          - invoiceNumber, supplierId
         """
         try:
-            invoice = Invoice.query.filter_by(invoiceNumber = invoiceNumber, supplierId = supplierId).first()
+            invoice = Invoice.query.filter_by(invoiceNumber=invoiceNumber, supplierId=supplierId).first()
             if invoice is None:
-                return invoice
+                return None
             else:
                 return invoice.to_thrift_object()
         finally:
             self.close_session()
         Parameters:
          - invoice
         """
         try:
-            if Invoice.query.filter_by(supplierId = invoice.supplierId, date = to_py_date(invoice.date), invoiceNumber = invoice.invoiceNumber).all():
+            if Invoice.query.filter_by(supplierId=invoice.supplierId, date=to_py_date(invoice.date), invoiceNumber=invoice.invoiceNumber).all():
                 raise PurchaseServiceException(ExceptionType.ILLEGAL_ARGUMENTS, "Already received such invoice")
             invoiceObj = Invoice()
             invoiceObj.invoiceNumber = invoice.invoiceNumber
             invoiceObj.date = to_py_date(invoice.date)
             invoiceObj.receivedFrom = invoice.receivedFrom
         '''
         For getting invoiceNumbers for a Purchase Order
         '''
         try:
-            purchases = Purchase.query.filter_by(purchaseOrder = poNumber)
+            purchases = Purchase.query.filter_by(purchaseOrder=poNumber)
             for purchase in purchases:
                 invoice = purchase.invoiceNumber
         except:
             return None
         finally:
     def createPurchaseReturn(self, t_purchaseReturn):
         '''
         For creating a new Purchase Return
         '''
         try:
-            purchaseReturn = PurchaseReturn(t_purchaseReturn.vendorId,t_purchaseReturn.amount)
+            purchaseReturn = PurchaseReturn(t_purchaseReturn.vendorId, t_purchaseReturn.amount)
             purchaseReturn.vendorId = t_purchaseReturn.vendorId
             purchaseReturn.amount = t_purchaseReturn.amount
             purchaseReturn.returnTimestamp = to_py_date(t_purchaseReturn.returnTimestamp)
             purchaseReturn.isSettled = False
             session.commit()
     def getUnsettledPurchaseReturns(self):
         '''
         For getting all unsettled Purchase Returns
         '''
         try:
-            purchaseReturns = PurchaseReturn.query.filter_by(isSettled = False).all()
+            purchaseReturns = PurchaseReturn.query.filter_by(isSettled=False).all()
             return [purchasereturn.to_thrift_object() for purchasereturn in purchaseReturns]
         except Exception as e:
             print e
             raise PurchaseServiceException(101, 'Exception while fetching all Unsettled Purchase Returns')
         finally:
     def settlePurchaseReturn(self, returnId):
         '''
         For marking a Purchase Return as settled
         '''
         try:
-            purchaseReturn = PurchaseReturn.query.filter_by(id = returnId).one()
+            purchaseReturn = PurchaseReturn.query.filter_by(id=returnId).one()
             purchaseReturn.isSettled = True
             session.commit()
         except Exception as e:
             print e
             raise PurchaseServiceException(101, 'Exception while settling Purchase Return Id : ' + id)
         finally:
             self.close_session()
+    def createPurchaseForOurExtBilling(self, invoiceNumber, unitPrice, itemId):
+        try:
+            poId = self.getPOforOurExternalBilling()
+            self.updatelineItemforOursExternalBilling(poId, itemId, unitPrice)
+            self.receiveinvoiceforOursExternalBilling(invoiceNumber)
+            return self.createPurchaseforOursExternalBilling(poId, invoiceNumber)
+        except Exception as e:
+            print e
+            raise PurchaseServiceException(101, '')
+        finally:
+            self.close_session()
+    def fulfillPOForExtBilling(self, itemId, quantity):
+        poId = self.getPOforOurExternalBilling()
+        lineItem = LineItem.get_by(purchaseOrder_id=poId, itemId=itemId)
+        lineItem.unfulfilledQuantity = lineItem.unfulfilledQuantity - 1
+        if not lineItem.unfulfilledQuantity:
+            lineItem.fulfilled = 1
+        session.commit()
-    def isAlive(self, ):
+    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()
         finally:
             self.close_session()
     def __get_item_from_master(self, item_id):
         client = CatalogClient("catalog_service_server_host_master", "catalog_service_server_port").get_client()
-        return client.getItem(item_id)
         return client.getItem(item_id)

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/purchase/main/handler/PurchaseServiceHandler.py – Rev 6638 → 6762