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

      - itemId
      - fulfilmentWarehouseId
     """
     pass
-  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
+  def scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
     """
     Scan non-serialized items.
     Parameters:
      - inventoryItem
      - type
      - quantity
      - billingWarehouseId
+     - transferLotId
     """
     pass
   def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
     """
      - freebieItemId
      - scanType
     """
     pass
+  def isItemTransferAllowed(self, warehouseId, transferWarehouseId):
+    """
+    Parameters:
+     - warehouseId
+     - transferWarehouseId
+    """
+    pass
+  def createTransferLot(self, originWarehouseId, destWarehouseId):
+    """
+    Parameters:
+     - originWarehouseId
+     - destWarehouseId
+    """
+    pass
+  def getTransferLot(self, transferLotId):
+    """
+    Parameters:
+     - transferLotId
+    """
+    pass
+  def markTransferLotAsReceived(self, id, remoteTransferRefNumber):
+    """
+    Parameters:
+     - id
+     - remoteTransferRefNumber
+    """
+    pass
+  def getTransferLotsByDate(self, fromDate, toDate):
+    """
+    Parameters:
+     - fromDate
+     - toDate
+    """
+    pass
+  def getAllowedDestinationWarehousesForTransfer(self, warehouseId):
+    """
+    Parameters:
+     - warehouseId
+    """
+    pass
+  def getItemsInTransferLot(self, transferLotId):
+    """
+    Parameters:
+     - transferLotId
+    """
+    pass
+  def markItemsAsReceivedForTransferLot(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def updateTransferLotAfterItemReceive(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def scanForTransfer(self, inventoryItems, type, transferLotId):
+    """
+    Parameters:
+     - inventoryItems
+     - type
+     - transferLotId
+    """
+    pass
 class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
   def __init__(self, iprot, oprot=None):
     shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
       return result.success
     if result.wex is not None:
       raise result.wex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonSeralizedInventoryItem failed: unknown result");
-  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
+  def scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
     """
     Scan non-serialized items.
     Parameters:
      - inventoryItem
      - type
      - quantity
      - billingWarehouseId
+     - transferLotId
     """
-    self.send_scan(inventoryItem, type, quantity, billingWarehouseId)
+    self.send_scan(inventoryItem, type, quantity, billingWarehouseId, transferLotId)
     self.recv_scan()
-  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId):
+  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
     self._oprot.writeMessageBegin('scan', TMessageType.CALL, self._seqid)
     args = scan_args()
     args.inventoryItem = inventoryItem
     args.type = type
     args.quantity = quantity
     args.billingWarehouseId = billingWarehouseId
+    args.transferLotId = transferLotId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_scan(self, ):
       self._iprot.readMessageEnd()
       raise x
     result = scanForOursExternalSaleReturn_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.ex is not None:
+      raise result.ex
     return
   def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
     """
     Parameters:
     self._iprot.readMessageEnd()
     if result.wex is not None:
       raise result.wex
     return
+  def isItemTransferAllowed(self, warehouseId, transferWarehouseId):
+    """
+    Parameters:
+     - warehouseId
+     - transferWarehouseId
+    """
+    self.send_isItemTransferAllowed(warehouseId, transferWarehouseId)
+    return self.recv_isItemTransferAllowed()
+  def send_isItemTransferAllowed(self, warehouseId, transferWarehouseId):
+    self._oprot.writeMessageBegin('isItemTransferAllowed', TMessageType.CALL, self._seqid)
+    args = isItemTransferAllowed_args()
+    args.warehouseId = warehouseId
+    args.transferWarehouseId = transferWarehouseId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_isItemTransferAllowed(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = isItemTransferAllowed_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "isItemTransferAllowed failed: unknown result");
+  def createTransferLot(self, originWarehouseId, destWarehouseId):
+    """
+    Parameters:
+     - originWarehouseId
+     - destWarehouseId
+    """
+    self.send_createTransferLot(originWarehouseId, destWarehouseId)
+    return self.recv_createTransferLot()
+  def send_createTransferLot(self, originWarehouseId, destWarehouseId):
+    self._oprot.writeMessageBegin('createTransferLot', TMessageType.CALL, self._seqid)
+    args = createTransferLot_args()
+    args.originWarehouseId = originWarehouseId
+    args.destWarehouseId = destWarehouseId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_createTransferLot(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createTransferLot_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.wex is not None:
+      raise result.wex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransferLot failed: unknown result");
+  def getTransferLot(self, transferLotId):
+    """
+    Parameters:
+     - transferLotId
+    """
+    self.send_getTransferLot(transferLotId)
+    return self.recv_getTransferLot()
+  def send_getTransferLot(self, transferLotId):
+    self._oprot.writeMessageBegin('getTransferLot', TMessageType.CALL, self._seqid)
+    args = getTransferLot_args()
+    args.transferLotId = transferLotId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTransferLot(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTransferLot_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.wex is not None:
+      raise result.wex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLot failed: unknown result");
+  def markTransferLotAsReceived(self, id, remoteTransferRefNumber):
+    """
+    Parameters:
+     - id
+     - remoteTransferRefNumber
+    """
+    self.send_markTransferLotAsReceived(id, remoteTransferRefNumber)
+    self.recv_markTransferLotAsReceived()
+  def send_markTransferLotAsReceived(self, id, remoteTransferRefNumber):
+    self._oprot.writeMessageBegin('markTransferLotAsReceived', TMessageType.CALL, self._seqid)
+    args = markTransferLotAsReceived_args()
+    args.id = id
+    args.remoteTransferRefNumber = remoteTransferRefNumber
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_markTransferLotAsReceived(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = markTransferLotAsReceived_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.wex is not None:
+      raise result.wex
+    return
+  def getTransferLotsByDate(self, fromDate, toDate):
+    """
+    Parameters:
+     - fromDate
+     - toDate
+    """
+    self.send_getTransferLotsByDate(fromDate, toDate)
+    return self.recv_getTransferLotsByDate()
+  def send_getTransferLotsByDate(self, fromDate, toDate):
+    self._oprot.writeMessageBegin('getTransferLotsByDate', TMessageType.CALL, self._seqid)
+    args = getTransferLotsByDate_args()
+    args.fromDate = fromDate
+    args.toDate = toDate
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTransferLotsByDate(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTransferLotsByDate_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.wex is not None:
+      raise result.wex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLotsByDate failed: unknown result");
+  def getAllowedDestinationWarehousesForTransfer(self, warehouseId):
+    """
+    Parameters:
+     - warehouseId
+    """
+    self.send_getAllowedDestinationWarehousesForTransfer(warehouseId)
+    return self.recv_getAllowedDestinationWarehousesForTransfer()
+  def send_getAllowedDestinationWarehousesForTransfer(self, warehouseId):
+    self._oprot.writeMessageBegin('getAllowedDestinationWarehousesForTransfer', TMessageType.CALL, self._seqid)
+    args = getAllowedDestinationWarehousesForTransfer_args()
+    args.warehouseId = warehouseId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getAllowedDestinationWarehousesForTransfer(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAllowedDestinationWarehousesForTransfer_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllowedDestinationWarehousesForTransfer failed: unknown result");
+  def getItemsInTransferLot(self, transferLotId):
+    """
+    Parameters:
+     - transferLotId
+    """
+    self.send_getItemsInTransferLot(transferLotId)
+    return self.recv_getItemsInTransferLot()
+  def send_getItemsInTransferLot(self, transferLotId):
+    self._oprot.writeMessageBegin('getItemsInTransferLot', TMessageType.CALL, self._seqid)
+    args = getItemsInTransferLot_args()
+    args.transferLotId = transferLotId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getItemsInTransferLot(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getItemsInTransferLot_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsInTransferLot failed: unknown result");
+  def markItemsAsReceivedForTransferLot(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_markItemsAsReceivedForTransferLot(id)
+    self.recv_markItemsAsReceivedForTransferLot()
+  def send_markItemsAsReceivedForTransferLot(self, id):
+    self._oprot.writeMessageBegin('markItemsAsReceivedForTransferLot', TMessageType.CALL, self._seqid)
+    args = markItemsAsReceivedForTransferLot_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_markItemsAsReceivedForTransferLot(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = markItemsAsReceivedForTransferLot_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.wex is not None:
+      raise result.wex
+    return
+  def updateTransferLotAfterItemReceive(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_updateTransferLotAfterItemReceive(id)
+    return self.recv_updateTransferLotAfterItemReceive()
+  def send_updateTransferLotAfterItemReceive(self, id):
+    self._oprot.writeMessageBegin('updateTransferLotAfterItemReceive', TMessageType.CALL, self._seqid)
+    args = updateTransferLotAfterItemReceive_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateTransferLotAfterItemReceive(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateTransferLotAfterItemReceive_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.wex is not None:
+      raise result.wex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTransferLotAfterItemReceive failed: unknown result");
+  def scanForTransfer(self, inventoryItems, type, transferLotId):
+    """
+    Parameters:
+     - inventoryItems
+     - type
+     - transferLotId
+    """
+    self.send_scanForTransfer(inventoryItems, type, transferLotId)
+    self.recv_scanForTransfer()
+  def send_scanForTransfer(self, inventoryItems, type, transferLotId):
+    self._oprot.writeMessageBegin('scanForTransfer', TMessageType.CALL, self._seqid)
+    args = scanForTransfer_args()
+    args.inventoryItems = inventoryItems
+    args.type = type
+    args.transferLotId = transferLotId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_scanForTransfer(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scanForTransfer_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.wex is not None:
+      raise result.wex
+    return
 class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
   def __init__(self, handler):
     shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
     self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
     self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
     self._processMap["getCompleteMovementSerializedInventoryByScans"] = Processor.process_getCompleteMovementSerializedInventoryByScans
     self._processMap["getCompleteMovementNonSerializedInventoryByScans"] = Processor.process_getCompleteMovementNonSerializedInventoryByScans
     self._processMap["scanfreebie"] = Processor.process_scanfreebie
     self._processMap["reshipfreebie"] = Processor.process_reshipfreebie
+    self._processMap["isItemTransferAllowed"] = Processor.process_isItemTransferAllowed
+    self._processMap["createTransferLot"] = Processor.process_createTransferLot
+    self._processMap["getTransferLot"] = Processor.process_getTransferLot
+    self._processMap["markTransferLotAsReceived"] = Processor.process_markTransferLotAsReceived
+    self._processMap["getTransferLotsByDate"] = Processor.process_getTransferLotsByDate
+    self._processMap["getAllowedDestinationWarehousesForTransfer"] = Processor.process_getAllowedDestinationWarehousesForTransfer
+    self._processMap["getItemsInTransferLot"] = Processor.process_getItemsInTransferLot
+    self._processMap["markItemsAsReceivedForTransferLot"] = Processor.process_markItemsAsReceivedForTransferLot
+    self._processMap["updateTransferLotAfterItemReceive"] = Processor.process_updateTransferLotAfterItemReceive
+    self._processMap["scanForTransfer"] = Processor.process_scanForTransfer
   def process(self, iprot, oprot):
     (name, type, seqid) = iprot.readMessageBegin()
     if name not in self._processMap:
       iprot.skip(TType.STRUCT)
     args = scan_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = scan_result()
     try:
-      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId)
+      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId, args.transferLotId)
     except WarehouseServiceException, wex:
       result.wex = wex
     oprot.writeMessageBegin("scan", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
   def process_scanForOursExternalSaleReturn(self, seqid, iprot, oprot):
     args = scanForOursExternalSaleReturn_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = scanForOursExternalSaleReturn_result()
+    try:
-    self._handler.scanForOursExternalSaleReturn(args.orderId, args.unitPrice)
+      self._handler.scanForOursExternalSaleReturn(args.orderId, args.unitPrice)
+    except WarehouseServiceException, ex:
+      result.ex = ex
     oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     oprot.writeMessageBegin("reshipfreebie", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_isItemTransferAllowed(self, seqid, iprot, oprot):
+    args = isItemTransferAllowed_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = isItemTransferAllowed_result()
+    result.success = self._handler.isItemTransferAllowed(args.warehouseId, args.transferWarehouseId)
+    oprot.writeMessageBegin("isItemTransferAllowed", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_createTransferLot(self, seqid, iprot, oprot):
+    args = createTransferLot_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createTransferLot_result()
+    try:
+      result.success = self._handler.createTransferLot(args.originWarehouseId, args.destWarehouseId)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("createTransferLot", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getTransferLot(self, seqid, iprot, oprot):
+    args = getTransferLot_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTransferLot_result()
+    try:
+      result.success = self._handler.getTransferLot(args.transferLotId)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("getTransferLot", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_markTransferLotAsReceived(self, seqid, iprot, oprot):
+    args = markTransferLotAsReceived_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = markTransferLotAsReceived_result()
+    try:
+      self._handler.markTransferLotAsReceived(args.id, args.remoteTransferRefNumber)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("markTransferLotAsReceived", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getTransferLotsByDate(self, seqid, iprot, oprot):
+    args = getTransferLotsByDate_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTransferLotsByDate_result()
+    try:
+      result.success = self._handler.getTransferLotsByDate(args.fromDate, args.toDate)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("getTransferLotsByDate", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getAllowedDestinationWarehousesForTransfer(self, seqid, iprot, oprot):
+    args = getAllowedDestinationWarehousesForTransfer_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAllowedDestinationWarehousesForTransfer_result()
+    result.success = self._handler.getAllowedDestinationWarehousesForTransfer(args.warehouseId)
+    oprot.writeMessageBegin("getAllowedDestinationWarehousesForTransfer", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getItemsInTransferLot(self, seqid, iprot, oprot):
+    args = getItemsInTransferLot_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getItemsInTransferLot_result()
+    result.success = self._handler.getItemsInTransferLot(args.transferLotId)
+    oprot.writeMessageBegin("getItemsInTransferLot", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_markItemsAsReceivedForTransferLot(self, seqid, iprot, oprot):
+    args = markItemsAsReceivedForTransferLot_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = markItemsAsReceivedForTransferLot_result()
+    try:
+      self._handler.markItemsAsReceivedForTransferLot(args.id)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("markItemsAsReceivedForTransferLot", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateTransferLotAfterItemReceive(self, seqid, iprot, oprot):
+    args = updateTransferLotAfterItemReceive_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateTransferLotAfterItemReceive_result()
+    try:
+      result.success = self._handler.updateTransferLotAfterItemReceive(args.id)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("updateTransferLotAfterItemReceive", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_scanForTransfer(self, seqid, iprot, oprot):
+    args = scanForTransfer_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = scanForTransfer_result()
+    try:
+      self._handler.scanForTransfer(args.inventoryItems, args.type, args.transferLotId)
+    except WarehouseServiceException, wex:
+      result.wex = wex
+    oprot.writeMessageBegin("scanForTransfer", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
 # HELPER FUNCTIONS AND STRUCTURES
 class getInventoryItem_args:
   """
   Attributes:
    - inventoryItem
    - type
    - quantity
    - billingWarehouseId
+   - transferLotId
   """
   thrift_spec = (
     None, # 0
     (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
     (2, TType.I32, 'type', None, None, ), # 2
     (3, TType.I64, 'quantity', None, None, ), # 3
     (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
+    (5, TType.I64, 'transferLotId', None, None, ), # 5
+  )
-  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None,):
+  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None, transferLotId=None,):
     self.inventoryItem = inventoryItem
     self.type = type
     self.quantity = quantity
     self.billingWarehouseId = billingWarehouseId
+    self.transferLotId = transferLotId
   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
       elif fid == 4:
         if ftype == TType.I64:
           self.billingWarehouseId = iprot.readI64();
         else:
           iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.I64:
+          self.transferLotId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
       oprot.writeFieldEnd()
     if self.billingWarehouseId is not None:
       oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
       oprot.writeI64(self.billingWarehouseId)
       oprot.writeFieldEnd()
+    if self.transferLotId is not None:
+      oprot.writeFieldBegin('transferLotId', TType.I64, 5)
+      oprot.writeI64(self.transferLotId)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return
    - serialNumber
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'serialNumber', None, None, ), # 1
+    (1, TType.STRING, 'serialNumber', None, None, ), # 1
+  )
   def __init__(self, serialNumber=None,):
     self.serialNumber = serialNumber
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.I64:
+        if ftype == TType.STRING:
-          self.serialNumber = iprot.readI64();
+          self.serialNumber = iprot.readString();
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     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('getScanRecordsForSerialNumber_args')
     if self.serialNumber is not None:
-      oprot.writeFieldBegin('serialNumber', TType.I64, 1)
+      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
-      oprot.writeI64(self.serialNumber)
+      oprot.writeString(self.serialNumber)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
   def __ne__(self, other):
     return not (self == other)
 class scanForOursExternalSaleReturn_result:
+  """
+  Attributes:
+   - ex
+  """
   thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, ex=None,):
+    self.ex = ex
   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.STRUCT:
+          self.ex = WarehouseServiceException()
+          self.ex.read(iprot)
+        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('scanForOursExternalSaleReturn_result')
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return
     if self.wex is not None:
       oprot.writeFieldBegin('wex', TType.STRUCT, 1)
       self.wex.write(oprot)
       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 isItemTransferAllowed_args:
+  """
+  Attributes:
+   - warehouseId
+   - transferWarehouseId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'warehouseId', None, None, ), # 1
+    (2, TType.I64, 'transferWarehouseId', None, None, ), # 2
+  )
+  def __init__(self, warehouseId=None, transferWarehouseId=None,):
+    self.warehouseId = warehouseId
+    self.transferWarehouseId = transferWarehouseId
+  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.warehouseId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.transferWarehouseId = 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('isItemTransferAllowed_args')
+    if self.warehouseId is not None:
+      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
+      oprot.writeI64(self.warehouseId)
+      oprot.writeFieldEnd()
+    if self.transferWarehouseId is not None:
+      oprot.writeFieldBegin('transferWarehouseId', TType.I64, 2)
+      oprot.writeI64(self.transferWarehouseId)
+      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 isItemTransferAllowed_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', 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.BOOL:
+          self.success = iprot.readBool();
+        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('isItemTransferAllowed_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      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 createTransferLot_args:
+  """
+  Attributes:
+   - originWarehouseId
+   - destWarehouseId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'originWarehouseId', None, None, ), # 1
+    (2, TType.I64, 'destWarehouseId', None, None, ), # 2
+  )
+  def __init__(self, originWarehouseId=None, destWarehouseId=None,):
+    self.originWarehouseId = originWarehouseId
+    self.destWarehouseId = destWarehouseId
+  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.originWarehouseId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.destWarehouseId = 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('createTransferLot_args')
+    if self.originWarehouseId is not None:
+      oprot.writeFieldBegin('originWarehouseId', TType.I64, 1)
+      oprot.writeI64(self.originWarehouseId)
+      oprot.writeFieldEnd()
+    if self.destWarehouseId is not None:
+      oprot.writeFieldBegin('destWarehouseId', TType.I64, 2)
+      oprot.writeI64(self.destWarehouseId)
+      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 createTransferLot_result:
+  """
+  Attributes:
+   - success
+   - wex
+  """
+  thrift_spec = (
+    (0, TType.I64, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, wex=None,):
+    self.success = success
+    self.wex = wex
+  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.I64:
+          self.success = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('createTransferLot_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.I64, 0)
+      oprot.writeI64(self.success)
+      oprot.writeFieldEnd()
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      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 getTransferLot_args:
+  """
+  Attributes:
+   - transferLotId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'transferLotId', None, None, ), # 1
+  )
+  def __init__(self, transferLotId=None,):
+    self.transferLotId = transferLotId
+  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.transferLotId = 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('getTransferLot_args')
+    if self.transferLotId is not None:
+      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
+      oprot.writeI64(self.transferLotId)
+      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 getTransferLot_result:
+  """
+  Attributes:
+   - success
+   - wex
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (TransferLot, TransferLot.thrift_spec), None, ), # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, wex=None,):
+    self.success = success
+    self.wex = wex
+  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.STRUCT:
+          self.success = TransferLot()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('getTransferLot_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      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 markTransferLotAsReceived_args:
+  """
+  Attributes:
+   - id
+   - remoteTransferRefNumber
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+    (2, TType.STRING, 'remoteTransferRefNumber', None, None, ), # 2
+  )
+  def __init__(self, id=None, remoteTransferRefNumber=None,):
+    self.id = id
+    self.remoteTransferRefNumber = remoteTransferRefNumber
+  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.id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.remoteTransferRefNumber = iprot.readString();
+        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('markTransferLotAsReceived_args')
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.id)
+      oprot.writeFieldEnd()
+    if self.remoteTransferRefNumber is not None:
+      oprot.writeFieldBegin('remoteTransferRefNumber', TType.STRING, 2)
+      oprot.writeString(self.remoteTransferRefNumber)
+      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 markTransferLotAsReceived_result:
+  """
+  Attributes:
+   - wex
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, wex=None,):
+    self.wex = wex
+  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.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('markTransferLotAsReceived_result')
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      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 getTransferLotsByDate_args:
+  """
+  Attributes:
+   - fromDate
+   - toDate
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'fromDate', None, None, ), # 1
+    (2, TType.I64, 'toDate', None, None, ), # 2
+  )
+  def __init__(self, fromDate=None, toDate=None,):
+    self.fromDate = fromDate
+    self.toDate = toDate
+  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.fromDate = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.toDate = 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('getTransferLotsByDate_args')
+    if self.fromDate is not None:
+      oprot.writeFieldBegin('fromDate', TType.I64, 1)
+      oprot.writeI64(self.fromDate)
+      oprot.writeFieldEnd()
+    if self.toDate is not None:
+      oprot.writeFieldBegin('toDate', TType.I64, 2)
+      oprot.writeI64(self.toDate)
+      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 getTransferLotsByDate_result:
+  """
+  Attributes:
+   - success
+   - wex
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(TransferLot, TransferLot.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, wex=None,):
+    self.success = success
+    self.wex = wex
+  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 = []
+          (_etype136, _size133) = iprot.readListBegin()
+          for _i137 in xrange(_size133):
+            _elem138 = TransferLot()
+            _elem138.read(iprot)
+            self.success.append(_elem138)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('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:
+        iter139.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      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 getAllowedDestinationWarehousesForTransfer_args:
+  """
+  Attributes:
+   - warehouseId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'warehouseId', None, None, ), # 1
+  )
+  def __init__(self, warehouseId=None,):
+    self.warehouseId = warehouseId
+  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.warehouseId = 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('getAllowedDestinationWarehousesForTransfer_args')
+    if self.warehouseId is not None:
+      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
+      oprot.writeI64(self.warehouseId)
+      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 getAllowedDestinationWarehousesForTransfer_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 = []
+          (_etype143, _size140) = iprot.readListBegin()
+          for _i144 in xrange(_size140):
+            _elem145 = iprot.readI64();
+            self.success.append(_elem145)
+          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('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:
+        oprot.writeI64(iter146)
+      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 getItemsInTransferLot_args:
+  """
+  Attributes:
+   - transferLotId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'transferLotId', None, None, ), # 1
+  )
+  def __init__(self, transferLotId=None,):
+    self.transferLotId = transferLotId
+  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.transferLotId = 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('getItemsInTransferLot_args')
+    if self.transferLotId is not None:
+      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
+      oprot.writeI64(self.transferLotId)
+      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 getItemsInTransferLot_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.MAP, 'success', (TType.I64,None,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.MAP:
+          self.success = {}
+          (_ktype148, _vtype149, _size147 ) = iprot.readMapBegin()
+          for _i151 in xrange(_size147):
+            _key152 = iprot.readI64();
+            _val153 = iprot.readI64();
+            self.success[_key152] = _val153
+          iprot.readMapEnd()
+        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('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():
+        oprot.writeI64(kiter154)
+        oprot.writeI64(viter155)
+      oprot.writeMapEnd()
+      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 markItemsAsReceivedForTransferLot_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    self.id = id
+  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.id = 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('markItemsAsReceivedForTransferLot_args')
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.id)
+      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 markItemsAsReceivedForTransferLot_result:
+  """
+  Attributes:
+   - wex
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, wex=None,):
+    self.wex = wex
+  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.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('markItemsAsReceivedForTransferLot_result')
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      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 updateTransferLotAfterItemReceive_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    self.id = id
+  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.id = 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('updateTransferLotAfterItemReceive_args')
+    if self.id is not None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.id)
+      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 updateTransferLotAfterItemReceive_result:
+  """
+  Attributes:
+   - success
+   - wex
+  """
+  thrift_spec = (
+    (0, TType.I32, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, wex=None,):
+    self.success = success
+    self.wex = wex
+  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.I32:
+          self.success = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('updateTransferLotAfterItemReceive_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.I32, 0)
+      oprot.writeI32(self.success)
+      oprot.writeFieldEnd()
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      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 scanForTransfer_args:
+  """
+  Attributes:
+   - inventoryItems
+   - type
+   - transferLotId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
+    (2, TType.I32, 'type', None, None, ), # 2
+    (3, TType.I64, 'transferLotId', None, None, ), # 3
+  )
+  def __init__(self, inventoryItems=None, type=None, transferLotId=None,):
+    self.inventoryItems = inventoryItems
+    self.type = type
+    self.transferLotId = transferLotId
+  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.LIST:
+          self.inventoryItems = []
+          (_etype159, _size156) = iprot.readListBegin()
+          for _i160 in xrange(_size156):
+            _elem161 = InventoryItem()
+            _elem161.read(iprot)
+            self.inventoryItems.append(_elem161)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I32:
+          self.type = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.transferLotId = 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('scanForTransfer_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:
+        iter162.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.type is not None:
+      oprot.writeFieldBegin('type', TType.I32, 2)
+      oprot.writeI32(self.type)
+      oprot.writeFieldEnd()
+    if self.transferLotId is not None:
+      oprot.writeFieldBegin('transferLotId', TType.I64, 3)
+      oprot.writeI64(self.transferLotId)
+      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 scanForTransfer_result:
+  """
+  Attributes:
+   - wex
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, wex=None,):
+    self.wex = wex
+  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.STRUCT:
+          self.wex = WarehouseServiceException()
+          self.wex.read(iprot)
+        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('scanForTransfer_result')
+    if self.wex is not None:
+      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
+      self.wex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return

Subversion Repositories SmartDukaan

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