Subversion Repositories SmartDukaan

Rev

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

Rev 6762 Rev 6766
Line 250... Line 250...
250 
     - orderId
 250 
     - orderId
251 
     - unitPrice
 251 
     - unitPrice
252 
    """
 252 
    """
253 
    pass
 253 
    pass
254 
 
 254 
 
255 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
 - 
 
256 
    """
 - 
 
257 
    Parameters:
 - 
 
258 
     - startDate
 - 
 
259 
     - endDate
 - 
 
260 
    """
 - 
 
261 
    pass
 - 
 
262 
 
 - 
 
263 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
 - 
 
264 
    """
 - 
 
265 
    Parameters:
 - 
 
266 
     - startDate
 - 
 
267 
     - endDate
 - 
 
268 
    """
 - 
 
269 
    pass
 - 
 
270 
 
 - 
 
271 
 
 255 
 
272 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
 256 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
273 
  def __init__(self, iprot, oprot=None):
 257 
  def __init__(self, iprot, oprot=None):
274 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
 258 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
275 
 
 259 
 
Line 1095... Line 1079...
1095 
    result = scanForOursExternalSaleReturn_result()
 1079 
    result = scanForOursExternalSaleReturn_result()
1096 
    result.read(self._iprot)
 1080 
    result.read(self._iprot)
1097 
    self._iprot.readMessageEnd()
 1081 
    self._iprot.readMessageEnd()
1098 
    return
 1082 
    return
1099 
 
 1083 
 
1100 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
 - 
 
1101 
    """
 - 
 
1102 
    Parameters:
 - 
 
1103 
     - startDate
 - 
 
1104 
     - endDate
 - 
 
1105 
    """
 - 
 
1106 
    self.send_getMovementNonSerializedInventoryByScans(startDate, endDate)
 - 
 
1107 
    return self.recv_getMovementNonSerializedInventoryByScans()
 - 
 
1108 
 
 - 
 
1109 
  def send_getMovementNonSerializedInventoryByScans(self, startDate, endDate):
 - 
 
1110 
    self._oprot.writeMessageBegin('getMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
 - 
 
1111 
    args = getMovementNonSerializedInventoryByScans_args()
 - 
 
1112 
    args.startDate = startDate
 - 
 
1113 
    args.endDate = endDate
 - 
 
1114 
    args.write(self._oprot)
 - 
 
1115 
    self._oprot.writeMessageEnd()
 - 
 
1116 
    self._oprot.trans.flush()
 - 
 
1117 
 
 - 
 
1118 
  def recv_getMovementNonSerializedInventoryByScans(self, ):
 - 
 
1119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1120 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1121 
      x = TApplicationException()
 - 
 
1122 
      x.read(self._iprot)
 - 
 
1123 
      self._iprot.readMessageEnd()
 - 
 
1124 
      raise x
 - 
 
1125 
    result = getMovementNonSerializedInventoryByScans_result()
 - 
 
1126 
    result.read(self._iprot)
 - 
 
1127 
    self._iprot.readMessageEnd()
 - 
 
1128 
    if result.success is not None:
 - 
 
1129 
      return result.success
 - 
 
1130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementNonSerializedInventoryByScans failed: unknown result");
 - 
 
1131 
 
 - 
 
1132 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
 - 
 
1133 
    """
 - 
 
1134 
    Parameters:
 - 
 
1135 
     - startDate
 - 
 
1136 
     - endDate
 - 
 
1137 
    """
 - 
 
1138 
    self.send_getMovementSerializedInventoryByScans(startDate, endDate)
 - 
 
1139 
    return self.recv_getMovementSerializedInventoryByScans()
 - 
 
1140 
 
 - 
 
1141 
  def send_getMovementSerializedInventoryByScans(self, startDate, endDate):
 - 
 
1142 
    self._oprot.writeMessageBegin('getMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
 - 
 
1143 
    args = getMovementSerializedInventoryByScans_args()
 - 
 
1144 
    args.startDate = startDate
 - 
 
1145 
    args.endDate = endDate
 - 
 
1146 
    args.write(self._oprot)
 - 
 
1147 
    self._oprot.writeMessageEnd()
 - 
 
1148 
    self._oprot.trans.flush()
 - 
 
1149 
 
 - 
 
1150 
  def recv_getMovementSerializedInventoryByScans(self, ):
 - 
 
1151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1152 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1153 
      x = TApplicationException()
 - 
 
1154 
      x.read(self._iprot)
 - 
 
1155 
      self._iprot.readMessageEnd()
 - 
 
1156 
      raise x
 - 
 
1157 
    result = getMovementSerializedInventoryByScans_result()
 - 
 
1158 
    result.read(self._iprot)
 - 
 
1159 
    self._iprot.readMessageEnd()
 - 
 
1160 
    if result.success is not None:
 - 
 
1161 
      return result.success
 - 
 
1162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementSerializedInventoryByScans failed: unknown result");
 - 
 
1163 
 
 - 
 
1164 
 
 1084 
 
1165 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
 1085 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
1166 
  def __init__(self, handler):
 1086 
  def __init__(self, handler):
1167 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
 1087 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
1168 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
 1088 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
Line 1187... Line 1107...
1187 
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
 1107 
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
1188 
    self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
 1108 
    self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
1189 
    self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
 1109 
    self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
1190 
    self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
 1110 
    self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
1191 
    self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
 1111 
    self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
1192 
    self._processMap["getMovementNonSerializedInventoryByScans"] = Processor.process_getMovementNonSerializedInventoryByScans
 - 
 
1193 
    self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
 - 
 
1194 
 
 1112 
 
1195 
  def process(self, iprot, oprot):
 1113 
  def process(self, iprot, oprot):
1196 
    (name, type, seqid) = iprot.readMessageBegin()
 1114 
    (name, type, seqid) = iprot.readMessageBegin()
1197 
    if name not in self._processMap:
 1115 
    if name not in self._processMap:
1198 
      iprot.skip(TType.STRUCT)
 1116 
      iprot.skip(TType.STRUCT)
Line 1502... Line 1420...
1502 
    oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
 1420 
    oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
1503 
    result.write(oprot)
 1421 
    result.write(oprot)
1504 
    oprot.writeMessageEnd()
 1422 
    oprot.writeMessageEnd()
1505 
    oprot.trans.flush()
 1423 
    oprot.trans.flush()
1506 
 
 1424 
 
1507 
  def process_getMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
 - 
 
1508 
    args = getMovementNonSerializedInventoryByScans_args()
 - 
 
1509 
    args.read(iprot)
 - 
 
1510 
    iprot.readMessageEnd()
 - 
 
1511 
    result = getMovementNonSerializedInventoryByScans_result()
 - 
 
1512 
    result.success = self._handler.getMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
 - 
 
1513 
    oprot.writeMessageBegin("getMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
 - 
 
1514 
    result.write(oprot)
 - 
 
1515 
    oprot.writeMessageEnd()
 - 
 
1516 
    oprot.trans.flush()
 - 
 
1517 
 
 - 
 
1518 
  def process_getMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
 - 
 
1519 
    args = getMovementSerializedInventoryByScans_args()
 - 
 
1520 
    args.read(iprot)
 - 
 
1521 
    iprot.readMessageEnd()
 - 
 
1522 
    result = getMovementSerializedInventoryByScans_result()
 - 
 
1523 
    result.success = self._handler.getMovementSerializedInventoryByScans(args.startDate, args.endDate)
 - 
 
1524 
    oprot.writeMessageBegin("getMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
 - 
 
1525 
    result.write(oprot)
 - 
 
1526 
    oprot.writeMessageEnd()
 - 
 
1527 
    oprot.trans.flush()
 - 
 
1528 
 
 - 
 
1529 
 
 1425 
 
1530 
# HELPER FUNCTIONS AND STRUCTURES
 1426 
# HELPER FUNCTIONS AND STRUCTURES
1531 
 
 1427 
 
1532 
class getInventoryItem_args:
 1428 
class getInventoryItem_args:
1533 
  """
 1429 
  """
Line 4861... Line 4757...
4861 
    oprot.writeFieldStop()
 4757 
    oprot.writeFieldStop()
4862 
    oprot.writeStructEnd()
 4758 
    oprot.writeStructEnd()
4863 
 
 4759 
 
4864 
  def validate(self):
 4760 
  def validate(self):
4865 
    return
 4761 
    return
4866 
 
 - 
 
4867 
 
 - 
 
4868 
  def __repr__(self):
 - 
 
4869 
    L = ['%s=%r' % (key, value)
 - 
 
4870 
      for key, value in self.__dict__.iteritems()]
 - 
 
4871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
4872 
 
 - 
 
4873 
  def __eq__(self, other):
 - 
 
4874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
4875 
 
 - 
 
4876 
  def __ne__(self, other):
 - 
 
4877 
    return not (self == other)
 - 
 
4878 
 
 - 
 
4879 
class getMovementNonSerializedInventoryByScans_args:
 - 
 
4880 
  """
 - 
 
4881 
  Attributes:
 - 
 
4882 
   - startDate
 - 
 
4883 
   - endDate
 - 
 
4884 
  """
 - 
 
4885 
 
 - 
 
4886 
  thrift_spec = (
 - 
 
4887 
    None, # 0
 - 
 
4888 
    (1, TType.I64, 'startDate', None, None, ), # 1
 - 
 
4889 
    (2, TType.I64, 'endDate', None, None, ), # 2
 - 
 
4890 
  )
 - 
 
4891 
 
 - 
 
4892 
  def __init__(self, startDate=None, endDate=None,):
 - 
 
4893 
    self.startDate = startDate
 - 
 
4894 
    self.endDate = endDate
 - 
 
4895 
 
 - 
 
4896 
  def read(self, iprot):
 - 
 
4897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
4898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
4899 
      return
 - 
 
4900 
    iprot.readStructBegin()
 - 
 
4901 
    while True:
 - 
 
4902 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
4903 
      if ftype == TType.STOP:
 - 
 
4904 
        break
 - 
 
4905 
      if fid == 1:
 - 
 
4906 
        if ftype == TType.I64:
 - 
 
4907 
          self.startDate = iprot.readI64();
 - 
 
4908 
        else:
 - 
 
4909 
          iprot.skip(ftype)
 - 
 
4910 
      elif fid == 2:
 - 
 
4911 
        if ftype == TType.I64:
 - 
 
4912 
          self.endDate = iprot.readI64();
 - 
 
4913 
        else:
 - 
 
4914 
          iprot.skip(ftype)
 - 
 
4915 
      else:
 - 
 
4916 
        iprot.skip(ftype)
 - 
 
4917 
      iprot.readFieldEnd()
 - 
 
4918 
    iprot.readStructEnd()
 - 
 
4919 
 
 - 
 
4920 
  def write(self, oprot):
 - 
 
4921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
4922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
4923 
      return
 - 
 
4924 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_args')
 - 
 
4925 
    if self.startDate is not None:
 - 
 
4926 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
 - 
 
4927 
      oprot.writeI64(self.startDate)
 - 
 
4928 
      oprot.writeFieldEnd()
 - 
 
4929 
    if self.endDate is not None:
 - 
 
4930 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
 - 
 
4931 
      oprot.writeI64(self.endDate)
 - 
 
4932 
      oprot.writeFieldEnd()
 - 
 
4933 
    oprot.writeFieldStop()
 - 
 
4934 
    oprot.writeStructEnd()
 - 
 
4935 
 
 - 
 
4936 
  def validate(self):
 - 
 
4937 
    return
 - 
 
4938 
 
 - 
 
4939 
 
 - 
 
4940 
  def __repr__(self):
 - 
 
4941 
    L = ['%s=%r' % (key, value)
 - 
 
4942 
      for key, value in self.__dict__.iteritems()]
 - 
 
4943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
4944 
 
 - 
 
4945 
  def __eq__(self, other):
 - 
 
4946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
4947 
 
 - 
 
4948 
  def __ne__(self, other):
 - 
 
4949 
    return not (self == other)
 - 
 
4950 
 
 - 
 
4951 
class getMovementNonSerializedInventoryByScans_result:
 - 
 
4952 
  """
 - 
 
4953 
  Attributes:
 - 
 
4954 
   - success
 - 
 
4955 
  """
 - 
 
4956 
 
 - 
 
4957 
  thrift_spec = (
 - 
 
4958 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
 - 
 
4959 
  )
 - 
 
4960 
 
 - 
 
4961 
  def __init__(self, success=None,):
 - 
 
4962 
    self.success = success
 - 
 
4963 
 
 - 
 
4964 
  def read(self, iprot):
 - 
 
4965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
4966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
4967 
      return
 - 
 
4968 
    iprot.readStructBegin()
 - 
 
4969 
    while True:
 - 
 
4970 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
4971 
      if ftype == TType.STOP:
 - 
 
4972 
        break
 - 
 
4973 
      if fid == 0:
 - 
 
4974 
        if ftype == TType.LIST:
 - 
 
4975 
          self.success = []
 - 
 
4976 
          (_etype101, _size98) = iprot.readListBegin()
 - 
 
4977 
          for _i102 in xrange(_size98):
 - 
 
4978 
            _elem103 = InventoryMovement()
 - 
 
4979 
            _elem103.read(iprot)
 - 
 
4980 
            self.success.append(_elem103)
 - 
 
4981 
          iprot.readListEnd()
 - 
 
4982 
        else:
 - 
 
4983 
          iprot.skip(ftype)
 - 
 
4984 
      else:
 - 
 
4985 
        iprot.skip(ftype)
 - 
 
4986 
      iprot.readFieldEnd()
 - 
 
4987 
    iprot.readStructEnd()
 - 
 
4988 
 
 - 
 
4989 
  def write(self, oprot):
 - 
 
4990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
4991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
4992 
      return
 - 
 
4993 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_result')
 - 
 
4994 
    if self.success is not None:
 - 
 
4995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
 - 
 
4996 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
 - 
 
4997 
      for iter104 in self.success:
 - 
 
4998 
        iter104.write(oprot)
 - 
 
4999 
      oprot.writeListEnd()
 - 
 
5000 
      oprot.writeFieldEnd()
 - 
 
5001 
    oprot.writeFieldStop()
 - 
 
5002 
    oprot.writeStructEnd()
 - 
 
5003 
 
 - 
 
5004 
  def validate(self):
 - 
 
5005 
    return
 - 
 
5006 
 
 - 
 
5007 
 
 - 
 
5008 
  def __repr__(self):
 - 
 
5009 
    L = ['%s=%r' % (key, value)
 - 
 
5010 
      for key, value in self.__dict__.iteritems()]
 - 
 
5011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5012 
 
 - 
 
5013 
  def __eq__(self, other):
 - 
 
5014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5015 
 
 - 
 
5016 
  def __ne__(self, other):
 - 
 
5017 
    return not (self == other)
 - 
 
5018 
 
 - 
 
5019 
class getMovementSerializedInventoryByScans_args:
 - 
 
5020 
  """
 - 
 
5021 
  Attributes:
 - 
 
5022 
   - startDate
 - 
 
5023 
   - endDate
 - 
 
5024 
  """
 - 
 
5025 
 
 - 
 
5026 
  thrift_spec = (
 - 
 
5027 
    None, # 0
 - 
 
5028 
    (1, TType.I64, 'startDate', None, None, ), # 1
 - 
 
5029 
    (2, TType.I64, 'endDate', None, None, ), # 2
 - 
 
5030 
  )
 - 
 
5031 
 
 - 
 
5032 
  def __init__(self, startDate=None, endDate=None,):
 - 
 
5033 
    self.startDate = startDate
 - 
 
5034 
    self.endDate = endDate
 - 
 
5035 
 
 - 
 
5036 
  def read(self, iprot):
 - 
 
5037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5039 
      return
 - 
 
5040 
    iprot.readStructBegin()
 - 
 
5041 
    while True:
 - 
 
5042 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5043 
      if ftype == TType.STOP:
 - 
 
5044 
        break
 - 
 
5045 
      if fid == 1:
 - 
 
5046 
        if ftype == TType.I64:
 - 
 
5047 
          self.startDate = iprot.readI64();
 - 
 
5048 
        else:
 - 
 
5049 
          iprot.skip(ftype)
 - 
 
5050 
      elif fid == 2:
 - 
 
5051 
        if ftype == TType.I64:
 - 
 
5052 
          self.endDate = iprot.readI64();
 - 
 
5053 
        else:
 - 
 
5054 
          iprot.skip(ftype)
 - 
 
5055 
      else:
 - 
 
5056 
        iprot.skip(ftype)
 - 
 
5057 
      iprot.readFieldEnd()
 - 
 
5058 
    iprot.readStructEnd()
 - 
 
5059 
 
 - 
 
5060 
  def write(self, oprot):
 - 
 
5061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5063 
      return
 - 
 
5064 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_args')
 - 
 
5065 
    if self.startDate is not None:
 - 
 
5066 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
 - 
 
5067 
      oprot.writeI64(self.startDate)
 - 
 
5068 
      oprot.writeFieldEnd()
 - 
 
5069 
    if self.endDate is not None:
 - 
 
5070 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
 - 
 
5071 
      oprot.writeI64(self.endDate)
 - 
 
5072 
      oprot.writeFieldEnd()
 - 
 
5073 
    oprot.writeFieldStop()
 - 
 
5074 
    oprot.writeStructEnd()
 - 
 
5075 
 
 - 
 
5076 
  def validate(self):
 - 
 
5077 
    return
 - 
 
5078 
 
 - 
 
5079 
 
 - 
 
5080 
  def __repr__(self):
 - 
 
5081 
    L = ['%s=%r' % (key, value)
 - 
 
5082 
      for key, value in self.__dict__.iteritems()]
 - 
 
5083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5084 
 
 - 
 
5085 
  def __eq__(self, other):
 - 
 
5086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5087 
 
 - 
 
5088 
  def __ne__(self, other):
 - 
 
5089 
    return not (self == other)
 - 
 
5090 
 
 - 
 
5091 
class getMovementSerializedInventoryByScans_result:
 - 
 
5092 
  """
 - 
 
5093 
  Attributes:
 - 
 
5094 
   - success
 - 
 
5095 
  """
 - 
 
5096 
 
 - 
 
5097 
  thrift_spec = (
 - 
 
5098 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
 - 
 
5099 
  )
 - 
 
5100 
 
 - 
 
5101 
  def __init__(self, success=None,):
 - 
 
5102 
    self.success = success
 - 
 
5103 
 
 - 
 
5104 
  def read(self, iprot):
 - 
 
5105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5107 
      return
 - 
 
5108 
    iprot.readStructBegin()
 - 
 
5109 
    while True:
 - 
 
5110 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5111 
      if ftype == TType.STOP:
 - 
 
5112 
        break
 - 
 
5113 
      if fid == 0:
 - 
 
5114 
        if ftype == TType.LIST:
 - 
 
5115 
          self.success = []
 - 
 
5116 
          (_etype108, _size105) = iprot.readListBegin()
 - 
 
5117 
          for _i109 in xrange(_size105):
 - 
 
5118 
            _elem110 = InventoryMovement()
 - 
 
5119 
            _elem110.read(iprot)
 - 
 
5120 
            self.success.append(_elem110)
 - 
 
5121 
          iprot.readListEnd()
 - 
 
5122 
        else:
 - 
 
5123 
          iprot.skip(ftype)
 - 
 
5124 
      else:
 - 
 
5125 
        iprot.skip(ftype)
 - 
 
5126 
      iprot.readFieldEnd()
 - 
 
5127 
    iprot.readStructEnd()
 - 
 
5128 
 
 - 
 
5129 
  def write(self, oprot):
 - 
 
5130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5132 
      return
 - 
 
5133 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_result')
 - 
 
5134 
    if self.success is not None:
 - 
 
5135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
 - 
 
5136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
 - 
 
5137 
      for iter111 in self.success:
 - 
 
5138 
        iter111.write(oprot)
 - 
 
5139 
      oprot.writeListEnd()
 - 
 
5140 
      oprot.writeFieldEnd()
 - 
 
5141 
    oprot.writeFieldStop()
 - 
 
5142 
    oprot.writeStructEnd()
 - 
 
5143 
 
 - 
 
5144 
  def validate(self):
 - 
 
5145 
    return
 - 
 
5146 
 
 4762 
 
5147 
 
 4763 
 
5148 
  def __repr__(self):
 4764 
  def __repr__(self):
5149 
    L = ['%s=%r' % (key, value)
 4765 
    L = ['%s=%r' % (key, value)
5150 
      for key, value in self.__dict__.iteritems()]
 4766 
      for key, value in self.__dict__.iteritems()]