Subversion Repositories SmartDukaan

Rev

Rev 5372 | Rev 5496 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5372 Rev 5437
Line 15... Line 15...
15 
except:
 15 
except:
16 
  fastbinary = None
 16 
  fastbinary = None
17 
 
 17 
 
18 
 
 18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def createSerializedInventoryItem(self, itemId, itemNumber, serialNumber, purchaseId):
 - 
 
21 
    """
 - 
 
22 
    Creating inventory for a serialized item
 - 
 
23 
 
 - 
 
24 
    Parameters:
 - 
 
25 
     - itemId
 - 
 
26 
     - itemNumber
 - 
 
27 
     - serialNumber
 - 
 
28 
     - purchaseId
 - 
 
29 
    """
 - 
 
30 
    pass
 - 
 
31 
 
 - 
 
32 
  def createSerializedInventoryItemFromItemNumber(self, itemNumber, serialNumber, purchaseId):
 - 
 
33 
    """
 - 
 
34 
    Creating inventory for a serialized item using item number
 - 
 
35 
 
 - 
 
36 
    Parameters:
 - 
 
37 
     - itemNumber
 - 
 
38 
     - serialNumber
 - 
 
39 
     - purchaseId
 - 
 
40 
    """
 - 
 
41 
    pass
 - 
 
42 
 
 - 
 
43 
  def createInventoryItem(self, itemId, quantity, purchaseId):
 - 
 
44 
    """
 - 
 
45 
    Creates inventory for an unserailized item
 - 
 
46 
 
 - 
 
47 
    Parameters:
 - 
 
48 
     - itemId
 - 
 
49 
     - quantity
 - 
 
50 
     - purchaseId
 - 
 
51 
    """
 - 
 
52 
    pass
 - 
 
53 
 
 - 
 
54 
  def getInventoryItem(self, serialNumber):
 20 
  def getInventoryItem(self, serialNumber):
55 
    """
 21 
    """
56 
    Retrieves serialized inventory item given a serial number
 22 
    Retrieves serialized inventory item given a serial number
57 
 
 23 
 
58 
    Parameters:
 24 
    Parameters:
Line 180... Line 146...
180 
 
 146 
 
181 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
 147 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
182 
  def __init__(self, iprot, oprot=None):
 148 
  def __init__(self, iprot, oprot=None):
183 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
 149 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
184 
 
 150 
 
185 
  def createSerializedInventoryItem(self, itemId, itemNumber, serialNumber, purchaseId):
 - 
 
186 
    """
 - 
 
187 
    Creating inventory for a serialized item
 - 
 
188 
 
 - 
 
189 
    Parameters:
 - 
 
190 
     - itemId
 - 
 
191 
     - itemNumber
 - 
 
192 
     - serialNumber
 - 
 
193 
     - purchaseId
 - 
 
194 
    """
 - 
 
195 
    self.send_createSerializedInventoryItem(itemId, itemNumber, serialNumber, purchaseId)
 - 
 
196 
    return self.recv_createSerializedInventoryItem()
 - 
 
197 
 
 - 
 
198 
  def send_createSerializedInventoryItem(self, itemId, itemNumber, serialNumber, purchaseId):
 - 
 
199 
    self._oprot.writeMessageBegin('createSerializedInventoryItem', TMessageType.CALL, self._seqid)
 - 
 
200 
    args = createSerializedInventoryItem_args()
 - 
 
201 
    args.itemId = itemId
 - 
 
202 
    args.itemNumber = itemNumber
 - 
 
203 
    args.serialNumber = serialNumber
 - 
 
204 
    args.purchaseId = purchaseId
 - 
 
205 
    args.write(self._oprot)
 - 
 
206 
    self._oprot.writeMessageEnd()
 - 
 
207 
    self._oprot.trans.flush()
 - 
 
208 
 
 - 
 
209 
  def recv_createSerializedInventoryItem(self, ):
 - 
 
210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
211 
    if mtype == TMessageType.EXCEPTION:
 - 
 
212 
      x = TApplicationException()
 - 
 
213 
      x.read(self._iprot)
 - 
 
214 
      self._iprot.readMessageEnd()
 - 
 
215 
      raise x
 - 
 
216 
    result = createSerializedInventoryItem_result()
 - 
 
217 
    result.read(self._iprot)
 - 
 
218 
    self._iprot.readMessageEnd()
 - 
 
219 
    if result.success is not None:
 - 
 
220 
      return result.success
 - 
 
221 
    if result.wex is not None:
 - 
 
222 
      raise result.wex
 - 
 
223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createSerializedInventoryItem failed: unknown result");
 - 
 
224 
 
 - 
 
225 
  def createSerializedInventoryItemFromItemNumber(self, itemNumber, serialNumber, purchaseId):
 - 
 
226 
    """
 - 
 
227 
    Creating inventory for a serialized item using item number
 - 
 
228 
 
 - 
 
229 
    Parameters:
 - 
 
230 
     - itemNumber
 - 
 
231 
     - serialNumber
 - 
 
232 
     - purchaseId
 - 
 
233 
    """
 - 
 
234 
    self.send_createSerializedInventoryItemFromItemNumber(itemNumber, serialNumber, purchaseId)
 - 
 
235 
    return self.recv_createSerializedInventoryItemFromItemNumber()
 - 
 
236 
 
 - 
 
237 
  def send_createSerializedInventoryItemFromItemNumber(self, itemNumber, serialNumber, purchaseId):
 - 
 
238 
    self._oprot.writeMessageBegin('createSerializedInventoryItemFromItemNumber', TMessageType.CALL, self._seqid)
 - 
 
239 
    args = createSerializedInventoryItemFromItemNumber_args()
 - 
 
240 
    args.itemNumber = itemNumber
 - 
 
241 
    args.serialNumber = serialNumber
 - 
 
242 
    args.purchaseId = purchaseId
 - 
 
243 
    args.write(self._oprot)
 - 
 
244 
    self._oprot.writeMessageEnd()
 - 
 
245 
    self._oprot.trans.flush()
 - 
 
246 
 
 - 
 
247 
  def recv_createSerializedInventoryItemFromItemNumber(self, ):
 - 
 
248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
249 
    if mtype == TMessageType.EXCEPTION:
 - 
 
250 
      x = TApplicationException()
 - 
 
251 
      x.read(self._iprot)
 - 
 
252 
      self._iprot.readMessageEnd()
 - 
 
253 
      raise x
 - 
 
254 
    result = createSerializedInventoryItemFromItemNumber_result()
 - 
 
255 
    result.read(self._iprot)
 - 
 
256 
    self._iprot.readMessageEnd()
 - 
 
257 
    if result.success is not None:
 - 
 
258 
      return result.success
 - 
 
259 
    if result.wex is not None:
 - 
 
260 
      raise result.wex
 - 
 
261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createSerializedInventoryItemFromItemNumber failed: unknown result");
 - 
 
262 
 
 - 
 
263 
  def createInventoryItem(self, itemId, quantity, purchaseId):
 - 
 
264 
    """
 - 
 
265 
    Creates inventory for an unserailized item
 - 
 
266 
 
 - 
 
267 
    Parameters:
 - 
 
268 
     - itemId
 - 
 
269 
     - quantity
 - 
 
270 
     - purchaseId
 - 
 
271 
    """
 - 
 
272 
    self.send_createInventoryItem(itemId, quantity, purchaseId)
 - 
 
273 
    return self.recv_createInventoryItem()
 - 
 
274 
 
 - 
 
275 
  def send_createInventoryItem(self, itemId, quantity, purchaseId):
 - 
 
276 
    self._oprot.writeMessageBegin('createInventoryItem', TMessageType.CALL, self._seqid)
 - 
 
277 
    args = createInventoryItem_args()
 - 
 
278 
    args.itemId = itemId
 - 
 
279 
    args.quantity = quantity
 - 
 
280 
    args.purchaseId = purchaseId
 - 
 
281 
    args.write(self._oprot)
 - 
 
282 
    self._oprot.writeMessageEnd()
 - 
 
283 
    self._oprot.trans.flush()
 - 
 
284 
 
 - 
 
285 
  def recv_createInventoryItem(self, ):
 - 
 
286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
287 
    if mtype == TMessageType.EXCEPTION:
 - 
 
288 
      x = TApplicationException()
 - 
 
289 
      x.read(self._iprot)
 - 
 
290 
      self._iprot.readMessageEnd()
 - 
 
291 
      raise x
 - 
 
292 
    result = createInventoryItem_result()
 - 
 
293 
    result.read(self._iprot)
 - 
 
294 
    self._iprot.readMessageEnd()
 - 
 
295 
    if result.success is not None:
 - 
 
296 
      return result.success
 - 
 
297 
    if result.wex is not None:
 - 
 
298 
      raise result.wex
 - 
 
299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createInventoryItem failed: unknown result");
 - 
 
300 
 
 - 
 
301 
  def getInventoryItem(self, serialNumber):
 151 
  def getInventoryItem(self, serialNumber):
302 
    """
 152 
    """
303 
    Retrieves serialized inventory item given a serial number
 153 
    Retrieves serialized inventory item given a serial number
304 
 
 154 
 
305 
    Parameters:
 155 
    Parameters:
Line 730... Line 580...
730 
 
 580 
 
731 
 
 581 
 
732 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
 582 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
733 
  def __init__(self, handler):
 583 
  def __init__(self, handler):
734 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
 584 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
735 
    self._processMap["createSerializedInventoryItem"] = Processor.process_createSerializedInventoryItem
 - 
 
736 
    self._processMap["createSerializedInventoryItemFromItemNumber"] = Processor.process_createSerializedInventoryItemFromItemNumber
 - 
 
737 
    self._processMap["createInventoryItem"] = Processor.process_createInventoryItem
 - 
 
738 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
 585 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
739 
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
 586 
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
740 
    self._processMap["scanSerializedItem"] = Processor.process_scanSerializedItem
 587 
    self._processMap["scanSerializedItem"] = Processor.process_scanSerializedItem
741 
    self._processMap["scan"] = Processor.process_scan
 588 
    self._processMap["scan"] = Processor.process_scan
742 
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
 589 
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
Line 761... Line 608...
761 
      return
 608 
      return
762 
    else:
 609 
    else:
763 
      self._processMap[name](self, seqid, iprot, oprot)
 610 
      self._processMap[name](self, seqid, iprot, oprot)
764 
    return True
 611 
    return True
765 
 
 612 
 
766 
  def process_createSerializedInventoryItem(self, seqid, iprot, oprot):
 - 
 
767 
    args = createSerializedInventoryItem_args()
 - 
 
768 
    args.read(iprot)
 - 
 
769 
    iprot.readMessageEnd()
 - 
 
770 
    result = createSerializedInventoryItem_result()
 - 
 
771 
    try:
 - 
 
772 
      result.success = self._handler.createSerializedInventoryItem(args.itemId, args.itemNumber, args.serialNumber, args.purchaseId)
 - 
 
773 
    except WarehouseServiceException, wex:
 - 
 
774 
      result.wex = wex
 - 
 
775 
    oprot.writeMessageBegin("createSerializedInventoryItem", TMessageType.REPLY, seqid)
 - 
 
776 
    result.write(oprot)
 - 
 
777 
    oprot.writeMessageEnd()
 - 
 
778 
    oprot.trans.flush()
 - 
 
779 
 
 - 
 
780 
  def process_createSerializedInventoryItemFromItemNumber(self, seqid, iprot, oprot):
 - 
 
781 
    args = createSerializedInventoryItemFromItemNumber_args()
 - 
 
782 
    args.read(iprot)
 - 
 
783 
    iprot.readMessageEnd()
 - 
 
784 
    result = createSerializedInventoryItemFromItemNumber_result()
 - 
 
785 
    try:
 - 
 
786 
      result.success = self._handler.createSerializedInventoryItemFromItemNumber(args.itemNumber, args.serialNumber, args.purchaseId)
 - 
 
787 
    except WarehouseServiceException, wex:
 - 
 
788 
      result.wex = wex
 - 
 
789 
    oprot.writeMessageBegin("createSerializedInventoryItemFromItemNumber", TMessageType.REPLY, seqid)
 - 
 
790 
    result.write(oprot)
 - 
 
791 
    oprot.writeMessageEnd()
 - 
 
792 
    oprot.trans.flush()
 - 
 
793 
 
 - 
 
794 
  def process_createInventoryItem(self, seqid, iprot, oprot):
 - 
 
795 
    args = createInventoryItem_args()
 - 
 
796 
    args.read(iprot)
 - 
 
797 
    iprot.readMessageEnd()
 - 
 
798 
    result = createInventoryItem_result()
 - 
 
799 
    try:
 - 
 
800 
      result.success = self._handler.createInventoryItem(args.itemId, args.quantity, args.purchaseId)
 - 
 
801 
    except WarehouseServiceException, wex:
 - 
 
802 
      result.wex = wex
 - 
 
803 
    oprot.writeMessageBegin("createInventoryItem", TMessageType.REPLY, seqid)
 - 
 
804 
    result.write(oprot)
 - 
 
805 
    oprot.writeMessageEnd()
 - 
 
806 
    oprot.trans.flush()
 - 
 
807 
 
 - 
 
808 
  def process_getInventoryItem(self, seqid, iprot, oprot):
 613 
  def process_getInventoryItem(self, seqid, iprot, oprot):
809 
    args = getInventoryItem_args()
 614 
    args = getInventoryItem_args()
810 
    args.read(iprot)
 615 
    args.read(iprot)
811 
    iprot.readMessageEnd()
 616 
    iprot.readMessageEnd()
812 
    result = getInventoryItem_result()
 617 
    result = getInventoryItem_result()
Line 962... Line 767...
962 
    oprot.trans.flush()
 767 
    oprot.trans.flush()
963 
 
 768 
 
964 
 
 769 
 
965 
# HELPER FUNCTIONS AND STRUCTURES
 770 
# HELPER FUNCTIONS AND STRUCTURES
966 
 
 771 
 
967 
class createSerializedInventoryItem_args:
 - 
 
968 
  """
 - 
 
969 
  Attributes:
 - 
 
970 
   - itemId
 - 
 
971 
   - itemNumber
 - 
 
972 
   - serialNumber
 - 
 
973 
   - purchaseId
 - 
 
974 
  """
 - 
 
975 
 
 - 
 
976 
  thrift_spec = (
 - 
 
977 
    None, # 0
 - 
 
978 
    (1, TType.I64, 'itemId', None, None, ), # 1
 - 
 
979 
    (2, TType.STRING, 'itemNumber', None, None, ), # 2
 - 
 
980 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
 - 
 
981 
    (4, TType.I64, 'purchaseId', None, None, ), # 4
 - 
 
982 
  )
 - 
 
983 
 
 - 
 
984 
  def __init__(self, itemId=None, itemNumber=None, serialNumber=None, purchaseId=None,):
 - 
 
985 
    self.itemId = itemId
 - 
 
986 
    self.itemNumber = itemNumber
 - 
 
987 
    self.serialNumber = serialNumber
 - 
 
988 
    self.purchaseId = purchaseId
 - 
 
989 
 
 - 
 
990 
  def read(self, iprot):
 - 
 
991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
993 
      return
 - 
 
994 
    iprot.readStructBegin()
 - 
 
995 
    while True:
 - 
 
996 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
997 
      if ftype == TType.STOP:
 - 
 
998 
        break
 - 
 
999 
      if fid == 1:
 - 
 
1000 
        if ftype == TType.I64:
 - 
 
1001 
          self.itemId = iprot.readI64();
 - 
 
1002 
        else:
 - 
 
1003 
          iprot.skip(ftype)
 - 
 
1004 
      elif fid == 2:
 - 
 
1005 
        if ftype == TType.STRING:
 - 
 
1006 
          self.itemNumber = iprot.readString();
 - 
 
1007 
        else:
 - 
 
1008 
          iprot.skip(ftype)
 - 
 
1009 
      elif fid == 3:
 - 
 
1010 
        if ftype == TType.STRING:
 - 
 
1011 
          self.serialNumber = iprot.readString();
 - 
 
1012 
        else:
 - 
 
1013 
          iprot.skip(ftype)
 - 
 
1014 
      elif fid == 4:
 - 
 
1015 
        if ftype == TType.I64:
 - 
 
1016 
          self.purchaseId = iprot.readI64();
 - 
 
1017 
        else:
 - 
 
1018 
          iprot.skip(ftype)
 - 
 
1019 
      else:
 - 
 
1020 
        iprot.skip(ftype)
 - 
 
1021 
      iprot.readFieldEnd()
 - 
 
1022 
    iprot.readStructEnd()
 - 
 
1023 
 
 - 
 
1024 
  def write(self, oprot):
 - 
 
1025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
1027 
      return
 - 
 
1028 
    oprot.writeStructBegin('createSerializedInventoryItem_args')
 - 
 
1029 
    if self.itemId is not None:
 - 
 
1030 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
 - 
 
1031 
      oprot.writeI64(self.itemId)
 - 
 
1032 
      oprot.writeFieldEnd()
 - 
 
1033 
    if self.itemNumber is not None:
 - 
 
1034 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 2)
 - 
 
1035 
      oprot.writeString(self.itemNumber)
 - 
 
1036 
      oprot.writeFieldEnd()
 - 
 
1037 
    if self.serialNumber is not None:
 - 
 
1038 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
 - 
 
1039 
      oprot.writeString(self.serialNumber)
 - 
 
1040 
      oprot.writeFieldEnd()
 - 
 
1041 
    if self.purchaseId is not None:
 - 
 
1042 
      oprot.writeFieldBegin('purchaseId', TType.I64, 4)
 - 
 
1043 
      oprot.writeI64(self.purchaseId)
 - 
 
1044 
      oprot.writeFieldEnd()
 - 
 
1045 
    oprot.writeFieldStop()
 - 
 
1046 
    oprot.writeStructEnd()
 - 
 
1047 
 
 - 
 
1048 
  def validate(self):
 - 
 
1049 
    return
 - 
 
1050 
 
 - 
 
1051 
 
 - 
 
1052 
  def __repr__(self):
 - 
 
1053 
    L = ['%s=%r' % (key, value)
 - 
 
1054 
      for key, value in self.__dict__.iteritems()]
 - 
 
1055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
1056 
 
 - 
 
1057 
  def __eq__(self, other):
 - 
 
1058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
1059 
 
 - 
 
1060 
  def __ne__(self, other):
 - 
 
1061 
    return not (self == other)
 - 
 
1062 
 
 - 
 
1063 
class createSerializedInventoryItem_result:
 - 
 
1064 
  """
 - 
 
1065 
  Attributes:
 - 
 
1066 
   - success
 - 
 
1067 
   - wex
 - 
 
1068 
  """
 - 
 
1069 
 
 - 
 
1070 
  thrift_spec = (
 - 
 
1071 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
 - 
 
1072 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
 - 
 
1073 
  )
 - 
 
1074 
 
 - 
 
1075 
  def __init__(self, success=None, wex=None,):
 - 
 
1076 
    self.success = success
 - 
 
1077 
    self.wex = wex
 - 
 
1078 
 
 - 
 
1079 
  def read(self, iprot):
 - 
 
1080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
1082 
      return
 - 
 
1083 
    iprot.readStructBegin()
 - 
 
1084 
    while True:
 - 
 
1085 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
1086 
      if ftype == TType.STOP:
 - 
 
1087 
        break
 - 
 
1088 
      if fid == 0:
 - 
 
1089 
        if ftype == TType.STRUCT:
 - 
 
1090 
          self.success = InventoryItem()
 - 
 
1091 
          self.success.read(iprot)
 - 
 
1092 
        else:
 - 
 
1093 
          iprot.skip(ftype)
 - 
 
1094 
      elif fid == 1:
 - 
 
1095 
        if ftype == TType.STRUCT:
 - 
 
1096 
          self.wex = WarehouseServiceException()
 - 
 
1097 
          self.wex.read(iprot)
 - 
 
1098 
        else:
 - 
 
1099 
          iprot.skip(ftype)
 - 
 
1100 
      else:
 - 
 
1101 
        iprot.skip(ftype)
 - 
 
1102 
      iprot.readFieldEnd()
 - 
 
1103 
    iprot.readStructEnd()
 - 
 
1104 
 
 - 
 
1105 
  def write(self, oprot):
 - 
 
1106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
1108 
      return
 - 
 
1109 
    oprot.writeStructBegin('createSerializedInventoryItem_result')
 - 
 
1110 
    if self.success is not None:
 - 
 
1111 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
 - 
 
1112 
      self.success.write(oprot)
 - 
 
1113 
      oprot.writeFieldEnd()
 - 
 
1114 
    if self.wex is not None:
 - 
 
1115 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
 - 
 
1116 
      self.wex.write(oprot)
 - 
 
1117 
      oprot.writeFieldEnd()
 - 
 
1118 
    oprot.writeFieldStop()
 - 
 
1119 
    oprot.writeStructEnd()
 - 
 
1120 
 
 - 
 
1121 
  def validate(self):
 - 
 
1122 
    return
 - 
 
1123 
 
 - 
 
1124 
 
 - 
 
1125 
  def __repr__(self):
 - 
 
1126 
    L = ['%s=%r' % (key, value)
 - 
 
1127 
      for key, value in self.__dict__.iteritems()]
 - 
 
1128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
1129 
 
 - 
 
1130 
  def __eq__(self, other):
 - 
 
1131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
1132 
 
 - 
 
1133 
  def __ne__(self, other):
 - 
 
1134 
    return not (self == other)
 - 
 
1135 
 
 - 
 
1136 
class createSerializedInventoryItemFromItemNumber_args:
 - 
 
1137 
  """
 - 
 
1138 
  Attributes:
 - 
 
1139 
   - itemNumber
 - 
 
1140 
   - serialNumber
 - 
 
1141 
   - purchaseId
 - 
 
1142 
  """
 - 
 
1143 
 
 - 
 
1144 
  thrift_spec = (
 - 
 
1145 
    None, # 0
 - 
 
1146 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
 - 
 
1147 
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
 - 
 
1148 
    (3, TType.I64, 'purchaseId', None, None, ), # 3
 - 
 
1149 
  )
 - 
 
1150 
 
 - 
 
1151 
  def __init__(self, itemNumber=None, serialNumber=None, purchaseId=None,):
 - 
 
1152 
    self.itemNumber = itemNumber
 - 
 
1153 
    self.serialNumber = serialNumber
 - 
 
1154 
    self.purchaseId = purchaseId
 - 
 
1155 
 
 - 
 
1156 
  def read(self, iprot):
 - 
 
1157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
1159 
      return
 - 
 
1160 
    iprot.readStructBegin()
 - 
 
1161 
    while True:
 - 
 
1162 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
1163 
      if ftype == TType.STOP:
 - 
 
1164 
        break
 - 
 
1165 
      if fid == 1:
 - 
 
1166 
        if ftype == TType.STRING:
 - 
 
1167 
          self.itemNumber = iprot.readString();
 - 
 
1168 
        else:
 - 
 
1169 
          iprot.skip(ftype)
 - 
 
1170 
      elif fid == 2:
 - 
 
1171 
        if ftype == TType.STRING:
 - 
 
1172 
          self.serialNumber = iprot.readString();
 - 
 
1173 
        else:
 - 
 
1174 
          iprot.skip(ftype)
 - 
 
1175 
      elif fid == 3:
 - 
 
1176 
        if ftype == TType.I64:
 - 
 
1177 
          self.purchaseId = iprot.readI64();
 - 
 
1178 
        else:
 - 
 
1179 
          iprot.skip(ftype)
 - 
 
1180 
      else:
 - 
 
1181 
        iprot.skip(ftype)
 - 
 
1182 
      iprot.readFieldEnd()
 - 
 
1183 
    iprot.readStructEnd()
 - 
 
1184 
 
 - 
 
1185 
  def write(self, oprot):
 - 
 
1186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
1188 
      return
 - 
 
1189 
    oprot.writeStructBegin('createSerializedInventoryItemFromItemNumber_args')
 - 
 
1190 
    if self.itemNumber is not None:
 - 
 
1191 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
 - 
 
1192 
      oprot.writeString(self.itemNumber)
 - 
 
1193 
      oprot.writeFieldEnd()
 - 
 
1194 
    if self.serialNumber is not None:
 - 
 
1195 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
 - 
 
1196 
      oprot.writeString(self.serialNumber)
 - 
 
1197 
      oprot.writeFieldEnd()
 - 
 
1198 
    if self.purchaseId is not None:
 - 
 
1199 
      oprot.writeFieldBegin('purchaseId', TType.I64, 3)
 - 
 
1200 
      oprot.writeI64(self.purchaseId)
 - 
 
1201 
      oprot.writeFieldEnd()
 - 
 
1202 
    oprot.writeFieldStop()
 - 
 
1203 
    oprot.writeStructEnd()
 - 
 
1204 
 
 - 
 
1205 
  def validate(self):
 - 
 
1206 
    return
 - 
 
1207 
 
 - 
 
1208 
 
 - 
 
1209 
  def __repr__(self):
 - 
 
1210 
    L = ['%s=%r' % (key, value)
 - 
 
1211 
      for key, value in self.__dict__.iteritems()]
 - 
 
1212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
1213 
 
 - 
 
1214 
  def __eq__(self, other):
 - 
 
1215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
1216 
 
 - 
 
1217 
  def __ne__(self, other):
 - 
 
1218 
    return not (self == other)
 - 
 
1219 
 
 - 
 
1220 
class createSerializedInventoryItemFromItemNumber_result:
 - 
 
1221 
  """
 - 
 
1222 
  Attributes:
 - 
 
1223 
   - success
 - 
 
1224 
   - wex
 - 
 
1225 
  """
 - 
 
1226 
 
 - 
 
1227 
  thrift_spec = (
 - 
 
1228 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
 - 
 
1229 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
 - 
 
1230 
  )
 - 
 
1231 
 
 - 
 
1232 
  def __init__(self, success=None, wex=None,):
 - 
 
1233 
    self.success = success
 - 
 
1234 
    self.wex = wex
 - 
 
1235 
 
 - 
 
1236 
  def read(self, iprot):
 - 
 
1237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
1239 
      return
 - 
 
1240 
    iprot.readStructBegin()
 - 
 
1241 
    while True:
 - 
 
1242 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
1243 
      if ftype == TType.STOP:
 - 
 
1244 
        break
 - 
 
1245 
      if fid == 0:
 - 
 
1246 
        if ftype == TType.STRUCT:
 - 
 
1247 
          self.success = InventoryItem()
 - 
 
1248 
          self.success.read(iprot)
 - 
 
1249 
        else:
 - 
 
1250 
          iprot.skip(ftype)
 - 
 
1251 
      elif fid == 1:
 - 
 
1252 
        if ftype == TType.STRUCT:
 - 
 
1253 
          self.wex = WarehouseServiceException()
 - 
 
1254 
          self.wex.read(iprot)
 - 
 
1255 
        else:
 - 
 
1256 
          iprot.skip(ftype)
 - 
 
1257 
      else:
 - 
 
1258 
        iprot.skip(ftype)
 - 
 
1259 
      iprot.readFieldEnd()
 - 
 
1260 
    iprot.readStructEnd()
 - 
 
1261 
 
 - 
 
1262 
  def write(self, oprot):
 - 
 
1263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
1265 
      return
 - 
 
1266 
    oprot.writeStructBegin('createSerializedInventoryItemFromItemNumber_result')
 - 
 
1267 
    if self.success is not None:
 - 
 
1268 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
 - 
 
1269 
      self.success.write(oprot)
 - 
 
1270 
      oprot.writeFieldEnd()
 - 
 
1271 
    if self.wex is not None:
 - 
 
1272 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
 - 
 
1273 
      self.wex.write(oprot)
 - 
 
1274 
      oprot.writeFieldEnd()
 - 
 
1275 
    oprot.writeFieldStop()
 - 
 
1276 
    oprot.writeStructEnd()
 - 
 
1277 
 
 - 
 
1278 
  def validate(self):
 - 
 
1279 
    return
 - 
 
1280 
 
 - 
 
1281 
 
 - 
 
1282 
  def __repr__(self):
 - 
 
1283 
    L = ['%s=%r' % (key, value)
 - 
 
1284 
      for key, value in self.__dict__.iteritems()]
 - 
 
1285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
1286 
 
 - 
 
1287 
  def __eq__(self, other):
 - 
 
1288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
1289 
 
 - 
 
1290 
  def __ne__(self, other):
 - 
 
1291 
    return not (self == other)
 - 
 
1292 
 
 - 
 
1293 
class createInventoryItem_args:
 - 
 
1294 
  """
 - 
 
1295 
  Attributes:
 - 
 
1296 
   - itemId
 - 
 
1297 
   - quantity
 - 
 
1298 
   - purchaseId
 - 
 
1299 
  """
 - 
 
1300 
 
 - 
 
1301 
  thrift_spec = (
 - 
 
1302 
    None, # 0
 - 
 
1303 
    (1, TType.I64, 'itemId', None, None, ), # 1
 - 
 
1304 
    (2, TType.I64, 'quantity', None, None, ), # 2
 - 
 
1305 
    (3, TType.I64, 'purchaseId', None, None, ), # 3
 - 
 
1306 
  )
 - 
 
1307 
 
 - 
 
1308 
  def __init__(self, itemId=None, quantity=None, purchaseId=None,):
 - 
 
1309 
    self.itemId = itemId
 - 
 
1310 
    self.quantity = quantity
 - 
 
1311 
    self.purchaseId = purchaseId
 - 
 
1312 
 
 - 
 
1313 
  def read(self, iprot):
 - 
 
1314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
1316 
      return
 - 
 
1317 
    iprot.readStructBegin()
 - 
 
1318 
    while True:
 - 
 
1319 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
1320 
      if ftype == TType.STOP:
 - 
 
1321 
        break
 - 
 
1322 
      if fid == 1:
 - 
 
1323 
        if ftype == TType.I64:
 - 
 
1324 
          self.itemId = iprot.readI64();
 - 
 
1325 
        else:
 - 
 
1326 
          iprot.skip(ftype)
 - 
 
1327 
      elif fid == 2:
 - 
 
1328 
        if ftype == TType.I64:
 - 
 
1329 
          self.quantity = iprot.readI64();
 - 
 
1330 
        else:
 - 
 
1331 
          iprot.skip(ftype)
 - 
 
1332 
      elif fid == 3:
 - 
 
1333 
        if ftype == TType.I64:
 - 
 
1334 
          self.purchaseId = iprot.readI64();
 - 
 
1335 
        else:
 - 
 
1336 
          iprot.skip(ftype)
 - 
 
1337 
      else:
 - 
 
1338 
        iprot.skip(ftype)
 - 
 
1339 
      iprot.readFieldEnd()
 - 
 
1340 
    iprot.readStructEnd()
 - 
 
1341 
 
 - 
 
1342 
  def write(self, oprot):
 - 
 
1343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
1345 
      return
 - 
 
1346 
    oprot.writeStructBegin('createInventoryItem_args')
 - 
 
1347 
    if self.itemId is not None:
 - 
 
1348 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
 - 
 
1349 
      oprot.writeI64(self.itemId)
 - 
 
1350 
      oprot.writeFieldEnd()
 - 
 
1351 
    if self.quantity is not None:
 - 
 
1352 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
 - 
 
1353 
      oprot.writeI64(self.quantity)
 - 
 
1354 
      oprot.writeFieldEnd()
 - 
 
1355 
    if self.purchaseId is not None:
 - 
 
1356 
      oprot.writeFieldBegin('purchaseId', TType.I64, 3)
 - 
 
1357 
      oprot.writeI64(self.purchaseId)
 - 
 
1358 
      oprot.writeFieldEnd()
 - 
 
1359 
    oprot.writeFieldStop()
 - 
 
1360 
    oprot.writeStructEnd()
 - 
 
1361 
 
 - 
 
1362 
  def validate(self):
 - 
 
1363 
    return
 - 
 
1364 
 
 - 
 
1365 
 
 - 
 
1366 
  def __repr__(self):
 - 
 
1367 
    L = ['%s=%r' % (key, value)
 - 
 
1368 
      for key, value in self.__dict__.iteritems()]
 - 
 
1369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
1370 
 
 - 
 
1371 
  def __eq__(self, other):
 - 
 
1372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
1373 
 
 - 
 
1374 
  def __ne__(self, other):
 - 
 
1375 
    return not (self == other)
 - 
 
1376 
 
 - 
 
1377 
class createInventoryItem_result:
 - 
 
1378 
  """
 - 
 
1379 
  Attributes:
 - 
 
1380 
   - success
 - 
 
1381 
   - wex
 - 
 
1382 
  """
 - 
 
1383 
 
 - 
 
1384 
  thrift_spec = (
 - 
 
1385 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
 - 
 
1386 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
 - 
 
1387 
  )
 - 
 
1388 
 
 - 
 
1389 
  def __init__(self, success=None, wex=None,):
 - 
 
1390 
    self.success = success
 - 
 
1391 
    self.wex = wex
 - 
 
1392 
 
 - 
 
1393 
  def read(self, iprot):
 - 
 
1394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
1396 
      return
 - 
 
1397 
    iprot.readStructBegin()
 - 
 
1398 
    while True:
 - 
 
1399 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
1400 
      if ftype == TType.STOP:
 - 
 
1401 
        break
 - 
 
1402 
      if fid == 0:
 - 
 
1403 
        if ftype == TType.STRUCT:
 - 
 
1404 
          self.success = InventoryItem()
 - 
 
1405 
          self.success.read(iprot)
 - 
 
1406 
        else:
 - 
 
1407 
          iprot.skip(ftype)
 - 
 
1408 
      elif fid == 1:
 - 
 
1409 
        if ftype == TType.STRUCT:
 - 
 
1410 
          self.wex = WarehouseServiceException()
 - 
 
1411 
          self.wex.read(iprot)
 - 
 
1412 
        else:
 - 
 
1413 
          iprot.skip(ftype)
 - 
 
1414 
      else:
 - 
 
1415 
        iprot.skip(ftype)
 - 
 
1416 
      iprot.readFieldEnd()
 - 
 
1417 
    iprot.readStructEnd()
 - 
 
1418 
 
 - 
 
1419 
  def write(self, oprot):
 - 
 
1420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
1421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
1422 
      return
 - 
 
1423 
    oprot.writeStructBegin('createInventoryItem_result')
 - 
 
1424 
    if self.success is not None:
 - 
 
1425 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
 - 
 
1426 
      self.success.write(oprot)
 - 
 
1427 
      oprot.writeFieldEnd()
 - 
 
1428 
    if self.wex is not None:
 - 
 
1429 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
 - 
 
1430 
      self.wex.write(oprot)
 - 
 
1431 
      oprot.writeFieldEnd()
 - 
 
1432 
    oprot.writeFieldStop()
 - 
 
1433 
    oprot.writeStructEnd()
 - 
 
1434 
 
 - 
 
1435 
  def validate(self):
 - 
 
1436 
    return
 - 
 
1437 
 
 - 
 
1438 
 
 - 
 
1439 
  def __repr__(self):
 - 
 
1440 
    L = ['%s=%r' % (key, value)
 - 
 
1441 
      for key, value in self.__dict__.iteritems()]
 - 
 
1442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
1443 
 
 - 
 
1444 
  def __eq__(self, other):
 - 
 
1445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
1446 
 
 - 
 
1447 
  def __ne__(self, other):
 - 
 
1448 
    return not (self == other)
 - 
 
1449 
 
 - 
 
1450 
class getInventoryItem_args:
 772 
class getInventoryItem_args:
1451 
  """
 773 
  """
1452 
  Attributes:
 774 
  Attributes:
1453 
   - serialNumber
 775 
   - serialNumber
1454 
  """
 776 
  """