WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/thriftpy/warehouse/WarehouseService.py

      - startDate
      - endDate
     """
     pass
+  def getEmptyGrnsByDate(self, startDate, endDate):
+    """
+    Returns the empty grn-ids between grn dates
+    Parameters:
+     - startDate
+     - endDate
+    """
+    pass
   def fetchScansPerInvoiceNumber(self, date):
     """
     Returns the invoices and the count of scans against on a given day.
     Parameters:
     Parameters:
      - date
     """
     pass
+  def getOurHistoricSerializedInventoryByScans(self, date):
+    """
+    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
+    Parameters:
+     - date
+    """
+    pass
+  def getOurHistoricNonSerializedInventoryByScans(self, date):
+    """
+    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
+    Parameters:
+     - date
+    """
+    pass
   def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
     """
     Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
     Parameters:
     """
     pass
   def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each non serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     pass
   def getMovementSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     pass
   def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each serialized item in the specified window.(Doesn't include Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     pass
   def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each non serialized item in the specified window.(Doesn't include Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     pass
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScansByGrnDate failed: unknown result");
+  def getEmptyGrnsByDate(self, startDate, endDate):
+    """
+    Returns the empty grn-ids between grn dates
+    Parameters:
+     - startDate
+     - endDate
+    """
+    self.send_getEmptyGrnsByDate(startDate, endDate)
+    return self.recv_getEmptyGrnsByDate()
+  def send_getEmptyGrnsByDate(self, startDate, endDate):
+    self._oprot.writeMessageBegin('getEmptyGrnsByDate', TMessageType.CALL, self._seqid)
+    args = getEmptyGrnsByDate_args()
+    args.startDate = startDate
+    args.endDate = endDate
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getEmptyGrnsByDate(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getEmptyGrnsByDate_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEmptyGrnsByDate failed: unknown result");
   def fetchScansPerInvoiceNumber(self, date):
     """
     Returns the invoices and the count of scans against on a given day.
     Parameters:
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricNonSerializedInventoryByScans failed: unknown result");
+  def getOurHistoricSerializedInventoryByScans(self, date):
+    """
+    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
+    Parameters:
+     - date
+    """
+    self.send_getOurHistoricSerializedInventoryByScans(date)
+    return self.recv_getOurHistoricSerializedInventoryByScans()
+  def send_getOurHistoricSerializedInventoryByScans(self, date):
+    self._oprot.writeMessageBegin('getOurHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
+    args = getOurHistoricSerializedInventoryByScans_args()
+    args.date = date
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getOurHistoricSerializedInventoryByScans(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getOurHistoricSerializedInventoryByScans_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurHistoricSerializedInventoryByScans failed: unknown result");
+  def getOurHistoricNonSerializedInventoryByScans(self, date):
+    """
+    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
+    Parameters:
+     - date
+    """
+    self.send_getOurHistoricNonSerializedInventoryByScans(date)
+    return self.recv_getOurHistoricNonSerializedInventoryByScans()
+  def send_getOurHistoricNonSerializedInventoryByScans(self, date):
+    self._oprot.writeMessageBegin('getOurHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
+    args = getOurHistoricNonSerializedInventoryByScans_args()
+    args.date = date
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getOurHistoricNonSerializedInventoryByScans(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getOurHistoricNonSerializedInventoryByScans_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurHistoricNonSerializedInventoryByScans failed: unknown result");
   def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
     """
     Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
     Parameters:
       raise result.ex
     return
   def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each non serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     self.send_getMovementNonSerializedInventoryByScans(startDate, endDate)
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementNonSerializedInventoryByScans failed: unknown result");
   def getMovementSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     self.send_getMovementSerializedInventoryByScans(startDate, endDate)
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementSerializedInventoryByScans failed: unknown result");
   def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each serialized item in the specified window.(Doesn't include Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     self.send_getCompleteMovementSerializedInventoryByScans(startDate, endDate)
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementSerializedInventoryByScans failed: unknown result");
   def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
     """
+    This returns movement for each non serialized item in the specified window.(Doesn't include Amazon w/h)
     Parameters:
      - startDate
      - endDate
     """
     self.send_getCompleteMovementNonSerializedInventoryByScans(startDate, endDate)
     self._processMap["getItemIds"] = Processor.process_getItemIds
     self._processMap["getInventoryItemsFromLastScanType"] = Processor.process_getInventoryItemsFromLastScanType
     self._processMap["getInventoryItemFromId"] = Processor.process_getInventoryItemFromId
     self._processMap["getPurchaseScans"] = Processor.process_getPurchaseScans
     self._processMap["getPurchaseScansByGrnDate"] = Processor.process_getPurchaseScansByGrnDate
+    self._processMap["getEmptyGrnsByDate"] = Processor.process_getEmptyGrnsByDate
     self._processMap["fetchScansPerInvoiceNumber"] = Processor.process_fetchScansPerInvoiceNumber
     self._processMap["getInventoryItemFromOrder"] = Processor.process_getInventoryItemFromOrder
     self._processMap["getInventoryAge"] = Processor.process_getInventoryAge
     self._processMap["getInventoryScansForItem"] = Processor.process_getInventoryScansForItem
     self._processMap["getScanRecordsForSerialNumber"] = Processor.process_getScanRecordsForSerialNumber
     self._processMap["scanForLostItem"] = Processor.process_scanForLostItem
     self._processMap["getCurrentSerializedInventoryByScans"] = Processor.process_getCurrentSerializedInventoryByScans
     self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
     self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
     self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
+    self._processMap["getOurHistoricSerializedInventoryByScans"] = Processor.process_getOurHistoricSerializedInventoryByScans
+    self._processMap["getOurHistoricNonSerializedInventoryByScans"] = Processor.process_getOurHistoricNonSerializedInventoryByScans
     self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
     self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
     self._processMap["getMovementNonSerializedInventoryByScans"] = Processor.process_getMovementNonSerializedInventoryByScans
     self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
     self._processMap["getCompleteMovementSerializedInventoryByScans"] = Processor.process_getCompleteMovementSerializedInventoryByScans
     oprot.writeMessageBegin("getPurchaseScansByGrnDate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getEmptyGrnsByDate(self, seqid, iprot, oprot):
+    args = getEmptyGrnsByDate_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getEmptyGrnsByDate_result()
+    result.success = self._handler.getEmptyGrnsByDate(args.startDate, args.endDate)
+    oprot.writeMessageBegin("getEmptyGrnsByDate", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_fetchScansPerInvoiceNumber(self, seqid, iprot, oprot):
     args = fetchScansPerInvoiceNumber_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = fetchScansPerInvoiceNumber_result()
     oprot.writeMessageBegin("getHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getOurHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
+    args = getOurHistoricSerializedInventoryByScans_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getOurHistoricSerializedInventoryByScans_result()
+    result.success = self._handler.getOurHistoricSerializedInventoryByScans(args.date)
+    oprot.writeMessageBegin("getOurHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getOurHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
+    args = getOurHistoricNonSerializedInventoryByScans_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getOurHistoricNonSerializedInventoryByScans_result()
+    result.success = self._handler.getOurHistoricNonSerializedInventoryByScans(args.date)
+    oprot.writeMessageBegin("getOurHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_scanForOursExternalSale(self, seqid, iprot, oprot):
     args = scanForOursExternalSale_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = scanForOursExternalSale_result()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class getEmptyGrnsByDate_args:
+  """
+  Attributes:
+   - startDate
+   - endDate
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'startDate', None, None, ), # 1
+    (2, TType.I64, 'endDate', None, None, ), # 2
+  )
+  def __init__(self, startDate=None, endDate=None,):
+    self.startDate = startDate
+    self.endDate = endDate
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.startDate = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.endDate = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEmptyGrnsByDate_args')
+    if self.startDate is not None:
+      oprot.writeFieldBegin('startDate', TType.I64, 1)
+      oprot.writeI64(self.startDate)
+      oprot.writeFieldEnd()
+    if self.endDate is not None:
+      oprot.writeFieldBegin('endDate', TType.I64, 2)
+      oprot.writeI64(self.endDate)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEmptyGrnsByDate_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype38, _size35) = iprot.readListBegin()
+          for _i39 in xrange(_size35):
+            _elem40 = iprot.readI64();
+            self.success.append(_elem40)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEmptyGrnsByDate_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.I64, len(self.success))
+      for iter41 in self.success:
+        oprot.writeI64(iter41)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
 class fetchScansPerInvoiceNumber_args:
   """
   Attributes:
    - date
   """
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype38, _size35) = iprot.readListBegin()
+          (_etype45, _size42) = iprot.readListBegin()
-          for _i39 in xrange(_size35):
+          for _i46 in xrange(_size42):
-            _elem40 = InvoiceScan()
+            _elem47 = InvoiceScan()
-            _elem40.read(iprot)
+            _elem47.read(iprot)
-            self.success.append(_elem40)
+            self.success.append(_elem47)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('fetchScansPerInvoiceNumber_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter41 in self.success:
+      for iter48 in self.success:
-        iter41.write(oprot)
+        iter48.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype45, _size42) = iprot.readListBegin()
+          (_etype52, _size49) = iprot.readListBegin()
-          for _i46 in xrange(_size42):
+          for _i53 in xrange(_size49):
-            _elem47 = InventoryAge()
+            _elem54 = InventoryAge()
-            _elem47.read(iprot)
+            _elem54.read(iprot)
-            self.success.append(_elem47)
+            self.success.append(_elem54)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getInventoryAge_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter48 in self.success:
+      for iter55 in self.success:
-        iter48.write(oprot)
+        iter55.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype52, _size49) = iprot.readListBegin()
+          (_etype59, _size56) = iprot.readListBegin()
-          for _i53 in xrange(_size49):
+          for _i60 in xrange(_size56):
-            _elem54 = Scan()
+            _elem61 = Scan()
-            _elem54.read(iprot)
+            _elem61.read(iprot)
-            self.success.append(_elem54)
+            self.success.append(_elem61)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getInventoryScansForItem_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter55 in self.success:
+      for iter62 in self.success:
-        iter55.write(oprot)
+        iter62.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype59, _size56) = iprot.readListBegin()
+          (_etype66, _size63) = iprot.readListBegin()
-          for _i60 in xrange(_size56):
+          for _i67 in xrange(_size63):
-            _elem61 = Scan()
+            _elem68 = Scan()
-            _elem61.read(iprot)
+            _elem68.read(iprot)
-            self.success.append(_elem61)
+            self.success.append(_elem68)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getScanRecordsForSerialNumber_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter62 in self.success:
+      for iter69 in self.success:
-        iter62.write(oprot)
+        iter69.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.saleReturnItems = []
-          (_etype66, _size63) = iprot.readListBegin()
+          (_etype73, _size70) = iprot.readListBegin()
-          for _i67 in xrange(_size63):
+          for _i74 in xrange(_size70):
-            _elem68 = InventoryItem()
+            _elem75 = InventoryItem()
-            _elem68.read(iprot)
+            _elem75.read(iprot)
-            self.saleReturnItems.append(_elem68)
+            self.saleReturnItems.append(_elem75)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('scanForPurchaseReturn_args')
     if self.saleReturnItems is not None:
       oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
-      for iter69 in self.saleReturnItems:
+      for iter76 in self.saleReturnItems:
-        iter69.write(oprot)
+        iter76.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.vendorId is not None:
       oprot.writeFieldBegin('vendorId', TType.I64, 2)
       oprot.writeI64(self.vendorId)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.lostItems = []
-          (_etype73, _size70) = iprot.readListBegin()
+          (_etype80, _size77) = iprot.readListBegin()
-          for _i74 in xrange(_size70):
+          for _i81 in xrange(_size77):
-            _elem75 = InventoryItem()
+            _elem82 = InventoryItem()
-            _elem75.read(iprot)
+            _elem82.read(iprot)
-            self.lostItems.append(_elem75)
+            self.lostItems.append(_elem82)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('scanForLostItem_args')
     if self.lostItems is not None:
       oprot.writeFieldBegin('lostItems', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.lostItems))
-      for iter76 in self.lostItems:
+      for iter83 in self.lostItems:
-        iter76.write(oprot)
+        iter83.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.vendorId is not None:
       oprot.writeFieldBegin('vendorId', TType.I64, 2)
       oprot.writeI64(self.vendorId)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype80, _size77) = iprot.readListBegin()
+          (_etype87, _size84) = iprot.readListBegin()
-          for _i81 in xrange(_size77):
+          for _i88 in xrange(_size84):
-            _elem82 = InventoryAvailability()
+            _elem89 = InventoryAvailability()
-            _elem82.read(iprot)
+            _elem89.read(iprot)
-            self.success.append(_elem82)
+            self.success.append(_elem89)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCurrentSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter83 in self.success:
+      for iter90 in self.success:
-        iter83.write(oprot)
+        iter90.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype87, _size84) = iprot.readListBegin()
+          (_etype94, _size91) = iprot.readListBegin()
-          for _i88 in xrange(_size84):
+          for _i95 in xrange(_size91):
-            _elem89 = InventoryAvailability()
+            _elem96 = InventoryAvailability()
-            _elem89.read(iprot)
+            _elem96.read(iprot)
-            self.success.append(_elem89)
+            self.success.append(_elem96)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter90 in self.success:
+      for iter97 in self.success:
-        iter90.write(oprot)
+        iter97.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype94, _size91) = iprot.readListBegin()
+          (_etype101, _size98) = iprot.readListBegin()
-          for _i95 in xrange(_size91):
+          for _i102 in xrange(_size98):
-            _elem96 = InventoryAvailability()
+            _elem103 = InventoryAvailability()
-            _elem96.read(iprot)
+            _elem103.read(iprot)
-            self.success.append(_elem96)
+            self.success.append(_elem103)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getHistoricSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter97 in self.success:
+      for iter104 in self.success:
-        iter97.write(oprot)
+        iter104.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype101, _size98) = iprot.readListBegin()
+          (_etype108, _size105) = iprot.readListBegin()
-          for _i102 in xrange(_size98):
+          for _i109 in xrange(_size105):
-            _elem103 = InventoryAvailability()
+            _elem110 = InventoryAvailability()
-            _elem103.read(iprot)
+            _elem110.read(iprot)
-            self.success.append(_elem103)
+            self.success.append(_elem110)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter111 in self.success:
+        iter111.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOurHistoricSerializedInventoryByScans_args:
+  """
+  Attributes:
+   - date
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'date', None, None, ), # 1
+  )
+  def __init__(self, date=None,):
+    self.date = date
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.date = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOurHistoricSerializedInventoryByScans_args')
+    if self.date is not None:
+      oprot.writeFieldBegin('date', TType.I64, 1)
+      oprot.writeI64(self.date)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOurHistoricSerializedInventoryByScans_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype115, _size112) = iprot.readListBegin()
+          for _i116 in xrange(_size112):
+            _elem117 = InventoryAvailability()
+            _elem117.read(iprot)
+            self.success.append(_elem117)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOurHistoricSerializedInventoryByScans_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter104 in self.success:
+      for iter118 in self.success:
-        iter104.write(oprot)
+        iter118.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOurHistoricNonSerializedInventoryByScans_args:
+  """
+  Attributes:
+   - date
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'date', None, None, ), # 1
+  )
+  def __init__(self, date=None,):
+    self.date = date
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.date = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOurHistoricNonSerializedInventoryByScans_args')
+    if self.date is not None:
+      oprot.writeFieldBegin('date', TType.I64, 1)
+      oprot.writeI64(self.date)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOurHistoricNonSerializedInventoryByScans_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype122, _size119) = iprot.readListBegin()
+          for _i123 in xrange(_size119):
+            _elem124 = InventoryAvailability()
+            _elem124.read(iprot)
+            self.success.append(_elem124)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOurHistoricNonSerializedInventoryByScans_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter125 in self.success:
+        iter125.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype108, _size105) = iprot.readListBegin()
+          (_etype129, _size126) = iprot.readListBegin()
-          for _i109 in xrange(_size105):
+          for _i130 in xrange(_size126):
-            _elem110 = InventoryMovement()
+            _elem131 = InventoryMovement()
-            _elem110.read(iprot)
+            _elem131.read(iprot)
-            self.success.append(_elem110)
+            self.success.append(_elem131)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter111 in self.success:
+      for iter132 in self.success:
-        iter111.write(oprot)
+        iter132.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype115, _size112) = iprot.readListBegin()
+          (_etype136, _size133) = iprot.readListBegin()
-          for _i116 in xrange(_size112):
+          for _i137 in xrange(_size133):
-            _elem117 = InventoryMovement()
+            _elem138 = InventoryMovement()
-            _elem117.read(iprot)
+            _elem138.read(iprot)
-            self.success.append(_elem117)
+            self.success.append(_elem138)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getMovementSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter118 in self.success:
+      for iter139 in self.success:
-        iter118.write(oprot)
+        iter139.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype122, _size119) = iprot.readListBegin()
+          (_etype143, _size140) = iprot.readListBegin()
-          for _i123 in xrange(_size119):
+          for _i144 in xrange(_size140):
-            _elem124 = InventoryMovement()
+            _elem145 = InventoryMovement()
-            _elem124.read(iprot)
+            _elem145.read(iprot)
-            self.success.append(_elem124)
+            self.success.append(_elem145)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCompleteMovementSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter125 in self.success:
+      for iter146 in self.success:
-        iter125.write(oprot)
+        iter146.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype129, _size126) = iprot.readListBegin()
+          (_etype150, _size147) = iprot.readListBegin()
-          for _i130 in xrange(_size126):
+          for _i151 in xrange(_size147):
-            _elem131 = InventoryMovement()
+            _elem152 = InventoryMovement()
-            _elem131.read(iprot)
+            _elem152.read(iprot)
-            self.success.append(_elem131)
+            self.success.append(_elem152)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getCompleteMovementNonSerializedInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter132 in self.success:
+      for iter153 in self.success:
-        iter132.write(oprot)
+        iter153.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype136, _size133) = iprot.readListBegin()
+          (_etype157, _size154) = iprot.readListBegin()
-          for _i137 in xrange(_size133):
+          for _i158 in xrange(_size154):
-            _elem138 = TransferLot()
+            _elem159 = TransferLot()
-            _elem138.read(iprot)
+            _elem159.read(iprot)
-            self.success.append(_elem138)
+            self.success.append(_elem159)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTransferLotsByDate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter139 in self.success:
+      for iter160 in self.success:
-        iter139.write(oprot)
+        iter160.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.wex is not None:
       oprot.writeFieldBegin('wex', TType.STRUCT, 1)
       self.wex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype143, _size140) = iprot.readListBegin()
+          (_etype164, _size161) = iprot.readListBegin()
-          for _i144 in xrange(_size140):
+          for _i165 in xrange(_size161):
-            _elem145 = iprot.readI64();
+            _elem166 = iprot.readI64();
-            self.success.append(_elem145)
+            self.success.append(_elem166)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllowedDestinationWarehousesForTransfer_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter146 in self.success:
+      for iter167 in self.success:
-        oprot.writeI64(iter146)
+        oprot.writeI64(iter167)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype148, _vtype149, _size147 ) = iprot.readMapBegin()
+          (_ktype169, _vtype170, _size168 ) = iprot.readMapBegin()
-          for _i151 in xrange(_size147):
+          for _i172 in xrange(_size168):
-            _key152 = iprot.readI64();
+            _key173 = iprot.readI64();
-            _val153 = iprot.readI64();
+            _val174 = iprot.readI64();
-            self.success[_key152] = _val153
+            self.success[_key173] = _val174
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getItemsInTransferLot_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
-      for kiter154,viter155 in self.success.items():
+      for kiter175,viter176 in self.success.items():
-        oprot.writeI64(kiter154)
+        oprot.writeI64(kiter175)
-        oprot.writeI64(viter155)
+        oprot.writeI64(viter176)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.inventoryItems = []
-          (_etype159, _size156) = iprot.readListBegin()
+          (_etype180, _size177) = iprot.readListBegin()
-          for _i160 in xrange(_size156):
+          for _i181 in xrange(_size177):
-            _elem161 = InventoryItem()
+            _elem182 = InventoryItem()
-            _elem161.read(iprot)
+            _elem182.read(iprot)
-            self.inventoryItems.append(_elem161)
+            self.inventoryItems.append(_elem182)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I32:
       return
     oprot.writeStructBegin('scanForTransferOut_args')
     if self.inventoryItems is not None:
       oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
-      for iter162 in self.inventoryItems:
+      for iter183 in self.inventoryItems:
-        iter162.write(oprot)
+        iter183.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.type is not None:
       oprot.writeFieldBegin('type', TType.I32, 2)
       oprot.writeI32(self.type)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.inventoryItems = []
-          (_etype166, _size163) = iprot.readListBegin()
+          (_etype187, _size184) = iprot.readListBegin()
-          for _i167 in xrange(_size163):
+          for _i188 in xrange(_size184):
-            _elem168 = InventoryItem()
+            _elem189 = InventoryItem()
-            _elem168.read(iprot)
+            _elem189.read(iprot)
-            self.inventoryItems.append(_elem168)
+            self.inventoryItems.append(_elem189)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I32:
       return
     oprot.writeStructBegin('scanForTransferIn_args')
     if self.inventoryItems is not None:
       oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
-      for iter169 in self.inventoryItems:
+      for iter190 in self.inventoryItems:
-        iter169.write(oprot)
+        iter190.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.type is not None:
       oprot.writeFieldBegin('type', TType.I32, 2)
       oprot.writeI32(self.type)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.inventoryItems = []
-          (_etype173, _size170) = iprot.readListBegin()
+          (_etype194, _size191) = iprot.readListBegin()
-          for _i174 in xrange(_size170):
+          for _i195 in xrange(_size191):
-            _elem175 = InventoryItem()
+            _elem196 = InventoryItem()
-            _elem175.read(iprot)
+            _elem196.read(iprot)
-            self.inventoryItems.append(_elem175)
+            self.inventoryItems.append(_elem196)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('scanForOursThirdPartyReceive_args')
     if self.inventoryItems is not None:
       oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
-      for iter176 in self.inventoryItems:
+      for iter197 in self.inventoryItems:
-        iter176.write(oprot)
+        iter197.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.id is not None:
       oprot.writeFieldBegin('id', TType.I64, 2)
       oprot.writeI64(self.id)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype180, _size177) = iprot.readListBegin()
+          (_etype201, _size198) = iprot.readListBegin()
-          for _i181 in xrange(_size177):
+          for _i202 in xrange(_size198):
-            _elem182 = InTransitInventory()
+            _elem203 = InTransitInventory()
-            _elem182.read(iprot)
+            _elem203.read(iprot)
-            self.success.append(_elem182)
+            self.success.append(_elem203)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getInTransitInventory_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter183 in self.success:
+      for iter204 in self.success:
-        iter183.write(oprot)
+        iter204.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype187, _size184) = iprot.readListBegin()
+          (_etype208, _size205) = iprot.readListBegin()
-          for _i188 in xrange(_size184):
+          for _i209 in xrange(_size205):
-            _elem189 = InventoryAvailability()
+            _elem210 = InventoryAvailability()
-            _elem189.read(iprot)
+            _elem210.read(iprot)
-            self.success.append(_elem189)
+            self.success.append(_elem210)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getHistoricBadInventoryByScans_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter190 in self.success:
+      for iter211 in self.success:
-        iter190.write(oprot)
+        iter211.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.wex is not None:
       oprot.writeFieldBegin('wex', TType.STRUCT, 1)
       self.wex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype194, _size191) = iprot.readListBegin()
+          (_etype215, _size212) = iprot.readListBegin()
-          for _i195 in xrange(_size191):
+          for _i216 in xrange(_size212):
-            _elem196 = InventoryItem()
+            _elem217 = InventoryItem()
-            _elem196.read(iprot)
+            _elem217.read(iprot)
-            self.success.append(_elem196)
+            self.success.append(_elem217)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTransferLotItemsForMarkReceive_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter197 in self.success:
+      for iter218 in self.success:
-        iter197.write(oprot)
+        iter218.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.wex is not None:
       oprot.writeFieldBegin('wex', TType.STRUCT, 1)
       self.wex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.inventoryItems = []
-          (_etype201, _size198) = iprot.readListBegin()
+          (_etype222, _size219) = iprot.readListBegin()
-          for _i202 in xrange(_size198):
+          for _i223 in xrange(_size219):
-            _elem203 = InventoryItem()
+            _elem224 = InventoryItem()
-            _elem203.read(iprot)
+            _elem224.read(iprot)
-            self.inventoryItems.append(_elem203)
+            self.inventoryItems.append(_elem224)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('markItemsAsReceivedForTransferLotPartial_args')
     if self.inventoryItems is not None:
       oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
-      for iter204 in self.inventoryItems:
+      for iter225 in self.inventoryItems:
-        iter204.write(oprot)
+        iter225.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.transferLotId is not None:
       oprot.writeFieldBegin('transferLotId', TType.I64, 2)
       oprot.writeI64(self.transferLotId)

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/thriftpy/warehouse/WarehouseService.py – Rev 10120 → 10407