WebSVN – SmartDukaan – Diff – //trunk/PyProj/src/shop2020/thriftpy/model/v1/user/UserContextService.py

     Parameters:
      - userId
     """
     pass
+  def getUserByCartId(self, cartId):
+    """
+    Parameters:
+     - cartId
+    """
+    pass
   def getUserByEmail(self, email):
     """
     Parameters:
      - email
     """
     Parameters:
      - userId
     """
     pass
-  def getUserState(self, userId):
-    """
-    Parameters:
-     - userId
-    """
-    pass
   def authenticateUser(self, email, password):
     """
     Parameters:
      - email
      - password
     Parameters:
      - cartId
     """
     pass
-  def getCartsForUser(self, userId, status):
-    """
-    Parameters:
-     - userId
-     - status
-    """
-    pass
-  def getCartsByStatus(self, status):
-    """
-    Parameters:
-     - status
-    """
-    pass
   def getCartsByTime(self, from_time, to_time, status):
     """
     Parameters:
      - from_time
      - to_time
      - status
     """
     pass
-  def changeCartStatus(self, cartId, status):
-    """
-    Parameters:
-     - cartId
-     - status
-    """
-    pass
   def addItemToCart(self, cartId, itemId, quantity, sourceId):
     """
     Parameters:
      - cartId
      - itemId
     Parameters:
      - discounts
     """
     pass
-  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime):
+  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId):
     """
     Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
     Parameters:
      - cartId
      - sessionSource
      - sessionStartTime
      - firstSource
      - firstSourceTime
+     - userId
     """
     pass
   def validateCart(self, cartId, sourceId):
     """
       return result.success
     if result.ucex is not None:
       raise result.ucex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
+  def getUserByCartId(self, cartId):
+    """
+    Parameters:
+     - cartId
+    """
+    self.send_getUserByCartId(cartId)
+    return self.recv_getUserByCartId()
+  def send_getUserByCartId(self, cartId):
+    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
+    args = getUserByCartId_args()
+    args.cartId = cartId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getUserByCartId(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getUserByCartId_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ucex is not None:
+      raise result.ucex
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
   def getUserByEmail(self, email):
     """
     Parameters:
      - email
     """
       return result.success
     if result.ucex is not None:
       raise result.ucex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
-  def getUserState(self, userId):
-    """
-    Parameters:
-     - userId
-    """
-    self.send_getUserState(userId)
-    return self.recv_getUserState()
-  def send_getUserState(self, userId):
-    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
-    args = getUserState_args()
-    args.userId = userId
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_getUserState(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getUserState_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.ucex is not None:
-      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
   def authenticateUser(self, email, password):
     """
     Parameters:
      - email
      - password
       return result.success
     if result.scx is not None:
       raise result.scx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
-  def getCartsForUser(self, userId, status):
-    """
-    Parameters:
-     - userId
-     - status
-    """
-    self.send_getCartsForUser(userId, status)
-    return self.recv_getCartsForUser()
-  def send_getCartsForUser(self, userId, status):
-    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
-    args = getCartsForUser_args()
-    args.userId = userId
-    args.status = status
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_getCartsForUser(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCartsForUser_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.scx is not None:
-      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
-  def getCartsByStatus(self, status):
-    """
-    Parameters:
-     - status
-    """
-    self.send_getCartsByStatus(status)
-    return self.recv_getCartsByStatus()
-  def send_getCartsByStatus(self, status):
-    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
-    args = getCartsByStatus_args()
-    args.status = status
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_getCartsByStatus(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getCartsByStatus_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
-    if result.scx is not None:
-      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
   def getCartsByTime(self, from_time, to_time, status):
     """
     Parameters:
      - from_time
      - to_time
       return result.success
     if result.scx is not None:
       raise result.scx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
-  def changeCartStatus(self, cartId, status):
-    """
-    Parameters:
-     - cartId
-     - status
-    """
-    self.send_changeCartStatus(cartId, status)
-    self.recv_changeCartStatus()
-  def send_changeCartStatus(self, cartId, status):
-    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
-    args = changeCartStatus_args()
-    args.cartId = cartId
-    args.status = status
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_changeCartStatus(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = changeCartStatus_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.scx is not None:
-      raise result.scx
-    return
   def addItemToCart(self, cartId, itemId, quantity, sourceId):
     """
     Parameters:
      - cartId
      - itemId
     self._iprot.readMessageEnd()
     if result.scx is not None:
       raise result.scx
     return
-  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime):
+  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId):
     """
     Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
     Parameters:
      - cartId
      - sessionSource
      - sessionStartTime
      - firstSource
      - firstSourceTime
+     - userId
     """
-    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime)
+    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId)
     return self.recv_createOrders()
-  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime):
+  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId):
     self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
     args = createOrders_args()
     args.cartId = cartId
     args.sessionSource = sessionSource
     args.sessionStartTime = sessionStartTime
     args.firstSource = firstSource
     args.firstSourceTime = firstSourceTime
+    args.userId = userId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_createOrders(self, ):
 class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
   def __init__(self, handler):
     shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
     self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
     self._processMap["getUserById"] = Processor.process_getUserById
+    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
     self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
     self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
     self._processMap["createUser"] = Processor.process_createUser
     self._processMap["updateUser"] = Processor.process_updateUser
     self._processMap["deleteUser"] = Processor.process_deleteUser
-    self._processMap["getUserState"] = Processor.process_getUserState
     self._processMap["authenticateUser"] = Processor.process_authenticateUser
     self._processMap["userExists"] = Processor.process_userExists
     self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
     self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
     self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
     self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
     self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
     self._processMap["createCart"] = Processor.process_createCart
     self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
     self._processMap["getCart"] = Processor.process_getCart
-    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
-    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
     self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
-    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
     self._processMap["addItemToCart"] = Processor.process_addItemToCart
     self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
     self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
     self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
     self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
     oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getUserByCartId(self, seqid, iprot, oprot):
+    args = getUserByCartId_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getUserByCartId_result()
+    try:
+      result.success = self._handler.getUserByCartId(args.cartId)
+    except UserContextException, ucex:
+      result.ucex = ucex
+    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_getUserByEmail(self, seqid, iprot, oprot):
     args = getUserByEmail_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getUserByEmail_result()
     oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getUserState(self, seqid, iprot, oprot):
-    args = getUserState_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getUserState_result()
-    try:
-      result.success = self._handler.getUserState(args.userId)
-    except UserContextException, ucex:
-      result.ucex = ucex
-    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_authenticateUser(self, seqid, iprot, oprot):
     args = authenticateUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = authenticateUser_result()
     oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getCartsForUser(self, seqid, iprot, oprot):
-    args = getCartsForUser_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCartsForUser_result()
-    try:
-      result.success = self._handler.getCartsForUser(args.userId, args.status)
-    except ShoppingCartException, scx:
-      result.scx = scx
-    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-  def process_getCartsByStatus(self, seqid, iprot, oprot):
-    args = getCartsByStatus_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getCartsByStatus_result()
-    try:
-      result.success = self._handler.getCartsByStatus(args.status)
-    except ShoppingCartException, scx:
-      result.scx = scx
-    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_getCartsByTime(self, seqid, iprot, oprot):
     args = getCartsByTime_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getCartsByTime_result()
     oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_changeCartStatus(self, seqid, iprot, oprot):
-    args = changeCartStatus_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = changeCartStatus_result()
-    try:
-      self._handler.changeCartStatus(args.cartId, args.status)
-    except ShoppingCartException, scx:
-      result.scx = scx
-    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_addItemToCart(self, seqid, iprot, oprot):
     args = addItemToCart_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = addItemToCart_result()
     args = createOrders_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = createOrders_result()
     try:
-      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime)
+      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId)
     except ShoppingCartException, scx:
       result.scx = scx
     oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUserByEmail_args:
+class getUserByCartId_args:
   """
   Attributes:
-   - email
+   - cartId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'email', None, None, ), # 1
+    (1, TType.I64, 'cartId', None, None, ), # 1
+  )
-  def __init__(self, email=None,):
+  def __init__(self, cartId=None,):
-    self.email = email
+    self.cartId = cartId
   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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.STRING:
+        if ftype == TType.I64:
-          self.email = iprot.readString();
+          self.cartId = iprot.readI64();
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   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('getUserByEmail_args')
+    oprot.writeStructBegin('getUserByCartId_args')
-    if self.email is not None:
+    if self.cartId is not None:
-      oprot.writeFieldBegin('email', TType.STRING, 1)
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
-      oprot.writeString(self.email)
+      oprot.writeI64(self.cartId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUserByEmail_result:
+class getUserByCartId_result:
   """
   Attributes:
    - success
    - ucex
   """
   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('getUserByEmail_result')
+    oprot.writeStructBegin('getUserByCartId_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.ucex is not None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUserByMobileNumber_args:
+class getUserByEmail_args:
   """
   Attributes:
-   - mobileNumber
+   - email
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'mobileNumber', None, None, ), # 1
+    (1, TType.STRING, 'email', None, None, ), # 1
+  )
-  def __init__(self, mobileNumber=None,):
+  def __init__(self, email=None,):
-    self.mobileNumber = mobileNumber
+    self.email = email
   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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.I64:
+        if ftype == TType.STRING:
-          self.mobileNumber = iprot.readI64();
+          self.email = iprot.readString();
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   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('getUserByMobileNumber_args')
+    oprot.writeStructBegin('getUserByEmail_args')
-    if self.mobileNumber is not None:
+    if self.email is not None:
-      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
+      oprot.writeFieldBegin('email', TType.STRING, 1)
-      oprot.writeI64(self.mobileNumber)
+      oprot.writeString(self.email)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUserByMobileNumber_result:
+class getUserByEmail_result:
   """
   Attributes:
    - success
    - ucex
   """
   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('getUserByMobileNumber_result')
+    oprot.writeStructBegin('getUserByEmail_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.ucex is not None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class createUser_args:
+class getUserByMobileNumber_args:
   """
   Attributes:
-   - user
+   - mobileNumber
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
+    (1, TType.I64, 'mobileNumber', None, None, ), # 1
+  )
-  def __init__(self, user=None,):
+  def __init__(self, mobileNumber=None,):
-    self.user = user
+    self.mobileNumber = mobileNumber
   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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.STRUCT:
+        if ftype == TType.I64:
-          self.user = User()
+          self.mobileNumber = iprot.readI64();
-          self.user.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   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('createUser_args')
+    oprot.writeStructBegin('getUserByMobileNumber_args')
-    if self.user is not None:
+    if self.mobileNumber is not None:
-      oprot.writeFieldBegin('user', TType.STRUCT, 1)
+      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
-      self.user.write(oprot)
+      oprot.writeI64(self.mobileNumber)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class createUser_result:
+class getUserByMobileNumber_result:
   """
   Attributes:
    - success
    - ucex
   """
   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('createUser_result')
+    oprot.writeStructBegin('getUserByMobileNumber_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.ucex is not None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class updateUser_args:
+class createUser_args:
   """
   Attributes:
    - user
   """
   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('updateUser_args')
+    oprot.writeStructBegin('createUser_args')
     if self.user is not None:
       oprot.writeFieldBegin('user', TType.STRUCT, 1)
       self.user.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class updateUser_result:
+class createUser_result:
   """
   Attributes:
    - success
    - ucex
   """
   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('updateUser_result')
+    oprot.writeStructBegin('createUser_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.ucex is not None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class deleteUser_args:
+class updateUser_args:
   """
   Attributes:
-   - userId
+   - user
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userId', None, None, ), # 1
+    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
+  )
-  def __init__(self, userId=None,):
+  def __init__(self, user=None,):
-    self.userId = userId
+    self.user = user
   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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.I64:
+        if ftype == TType.STRUCT:
-          self.userId = iprot.readI64();
+          self.user = User()
+          self.user.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   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('deleteUser_args')
+    oprot.writeStructBegin('updateUser_args')
-    if self.userId is not None:
+    if self.user is not None:
-      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeFieldBegin('user', TType.STRUCT, 1)
-      oprot.writeI64(self.userId)
+      self.user.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class deleteUser_result:
+class updateUser_result:
   """
   Attributes:
    - success
    - ucex
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
     (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ucex=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.STRUCT:
-          self.success = iprot.readBool();
+          self.success = User()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ucex = UserContextException()
   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('deleteUser_result')
+    oprot.writeStructBegin('updateUser_result')
     if self.success is not None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
-      oprot.writeBool(self.success)
+      self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.ucex is not None:
       oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
       self.ucex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUserState_args:
+class deleteUser_args:
   """
   Attributes:
    - userId
   """
   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('getUserState_args')
+    oprot.writeStructBegin('deleteUser_args')
     if self.userId is not None:
       oprot.writeFieldBegin('userId', TType.I64, 1)
       oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUserState_result:
+class deleteUser_result:
   """
   Attributes:
    - success
    - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
     (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ucex=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.STRUCT:
+        if ftype == TType.BOOL:
-          self.success = UserState()
+          self.success = iprot.readBool();
-          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ucex = UserContextException()
   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('getUserState_result')
+    oprot.writeStructBegin('deleteUser_result')
     if self.success is not None:
-      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
-      self.success.write(oprot)
+      oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ucex is not None:
       oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
       self.ucex.write(oprot)
       oprot.writeFieldEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype68, _size65) = iprot.readListBegin()
+          (_etype61, _size58) = iprot.readListBegin()
-          for _i69 in xrange(_size65):
+          for _i62 in xrange(_size58):
-            _elem70 = Address()
+            _elem63 = Address()
-            _elem70.read(iprot)
+            _elem63.read(iprot)
-            self.success.append(_elem70)
+            self.success.append(_elem63)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllAddressesForUser_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter71 in self.success:
+      for iter64 in self.success:
-        iter71.write(oprot)
+        iter64.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ucx is not None:
       oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
       self.ucx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype75, _size72) = iprot.readListBegin()
+          (_etype68, _size65) = iprot.readListBegin()
-          for _i76 in xrange(_size72):
+          for _i69 in xrange(_size65):
-            _elem77 = UserCommunication()
+            _elem70 = UserCommunication()
-            _elem77.read(iprot)
+            _elem70.read(iprot)
-            self.success.append(_elem77)
+            self.success.append(_elem70)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getUserCommunicationByUser_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter78 in self.success:
+      for iter71 in self.success:
-        iter78.write(oprot)
+        iter71.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ucx is not None:
       oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
       self.ucx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype82, _size79) = iprot.readListBegin()
+          (_etype75, _size72) = iprot.readListBegin()
-          for _i83 in xrange(_size79):
+          for _i76 in xrange(_size72):
-            _elem84 = UserCommunication()
+            _elem77 = UserCommunication()
-            _elem84.read(iprot)
+            _elem77.read(iprot)
-            self.success.append(_elem84)
+            self.success.append(_elem77)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllUserCommunications_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter85 in self.success:
+      for iter78 in self.success:
-        iter85.write(oprot)
+        iter78.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ucx is not None:
       oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
       self.ucx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype89, _size86) = iprot.readListBegin()
+          (_etype82, _size79) = iprot.readListBegin()
-          for _i90 in xrange(_size86):
+          for _i83 in xrange(_size79):
-            _elem91 = MasterAffiliate()
+            _elem84 = MasterAffiliate()
-            _elem91.read(iprot)
+            _elem84.read(iprot)
-            self.success.append(_elem91)
+            self.success.append(_elem84)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllMasterAffiliates_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter92 in self.success:
+      for iter85 in self.success:
-        iter92.write(oprot)
+        iter85.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx is not None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype96, _size93) = iprot.readListBegin()
+          (_etype89, _size86) = iprot.readListBegin()
-          for _i97 in xrange(_size93):
+          for _i90 in xrange(_size86):
-            _elem98 = Affiliate()
+            _elem91 = Affiliate()
-            _elem98.read(iprot)
+            _elem91.read(iprot)
-            self.success.append(_elem98)
+            self.success.append(_elem91)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter99 in self.success:
+      for iter92 in self.success:
-        iter99.write(oprot)
+        iter92.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx is not None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype103, _size100) = iprot.readListBegin()
+          (_etype96, _size93) = iprot.readListBegin()
-          for _i104 in xrange(_size100):
+          for _i97 in xrange(_size93):
-            _elem105 = TrackLog()
+            _elem98 = TrackLog()
-            _elem105.read(iprot)
+            _elem98.read(iprot)
-            self.success.append(_elem105)
+            self.success.append(_elem98)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTrackLogsByAffiliate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter106 in self.success:
+      for iter99 in self.success:
-        iter106.write(oprot)
+        iter99.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx is not None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype110, _size107) = iprot.readListBegin()
+          (_etype103, _size100) = iprot.readListBegin()
-          for _i111 in xrange(_size107):
+          for _i104 in xrange(_size100):
-            _elem112 = TrackLog()
+            _elem105 = TrackLog()
-            _elem112.read(iprot)
+            _elem105.read(iprot)
-            self.success.append(_elem112)
+            self.success.append(_elem105)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTrackLogsByUser_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter113 in self.success:
+      for iter106 in self.success:
-        iter113.write(oprot)
+        iter106.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx is not None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype117, _size114) = iprot.readListBegin()
+          (_etype110, _size107) = iprot.readListBegin()
-          for _i118 in xrange(_size114):
+          for _i111 in xrange(_size107):
-            _elem119 = TrackLog()
+            _elem112 = TrackLog()
-            _elem119.read(iprot)
+            _elem112.read(iprot)
-            self.success.append(_elem119)
+            self.success.append(_elem112)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getTrackLogs_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter120 in self.success:
+      for iter113 in self.success:
-        iter120.write(oprot)
+        iter113.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx is not None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getCartsForUser_args:
-  """
-  Attributes:
-   - userId
-   - status
-  """
-  thrift_spec = (
-    None, # 0
-    (1, TType.I64, 'userId', None, None, ), # 1
-    (2, TType.I32, 'status', None, None, ), # 2
-  )
-  def __init__(self, userId=None, status=None,):
-    self.userId = userId
-    self.status = status
-  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.userId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I32:
-          self.status = iprot.readI32();
-        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('getCartsForUser_args')
-    if self.userId is not None:
-      oprot.writeFieldBegin('userId', TType.I64, 1)
-      oprot.writeI64(self.userId)
-      oprot.writeFieldEnd()
-    if self.status is not None:
-      oprot.writeFieldBegin('status', TType.I32, 2)
-      oprot.writeI32(self.status)
-      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 getCartsForUser_result:
-  """
-  Attributes:
-   - success
-   - scx
-  """
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
-  )
-  def __init__(self, success=None, scx=None,):
-    self.success = success
-    self.scx = scx
-  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 = []
-          (_etype124, _size121) = iprot.readListBegin()
-          for _i125 in xrange(_size121):
-            _elem126 = Cart()
-            _elem126.read(iprot)
-            self.success.append(_elem126)
-          iprot.readListEnd()
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
-        if ftype == TType.STRUCT:
-          self.scx = ShoppingCartException()
-          self.scx.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('getCartsForUser_result')
-    if self.success is not None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter127 in self.success:
-        iter127.write(oprot)
-      oprot.writeListEnd()
-      oprot.writeFieldEnd()
-    if self.scx is not None:
-      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.scx.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 getCartsByStatus_args:
-  """
-  Attributes:
-   - status
-  """
-  thrift_spec = (
-    None, # 0
-    (1, TType.I32, 'status', None, None, ), # 1
-  )
-  def __init__(self, status=None,):
-    self.status = status
-  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.I32:
-          self.status = iprot.readI32();
-        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('getCartsByStatus_args')
-    if self.status is not None:
-      oprot.writeFieldBegin('status', TType.I32, 1)
-      oprot.writeI32(self.status)
-      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 getCartsByStatus_result:
-  """
-  Attributes:
-   - success
-   - scx
-  """
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
-  )
-  def __init__(self, success=None, scx=None,):
-    self.success = success
-    self.scx = scx
-  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 = []
-          (_etype131, _size128) = iprot.readListBegin()
-          for _i132 in xrange(_size128):
-            _elem133 = Cart()
-            _elem133.read(iprot)
-            self.success.append(_elem133)
-          iprot.readListEnd()
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
-        if ftype == TType.STRUCT:
-          self.scx = ShoppingCartException()
-          self.scx.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('getCartsByStatus_result')
-    if self.success is not None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter134 in self.success:
-        iter134.write(oprot)
-      oprot.writeListEnd()
-      oprot.writeFieldEnd()
-    if self.scx is not None:
-      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.scx.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 getCartsByTime_args:
   """
   Attributes:
    - from_time
    - to_time
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype138, _size135) = iprot.readListBegin()
+          (_etype117, _size114) = iprot.readListBegin()
-          for _i139 in xrange(_size135):
+          for _i118 in xrange(_size114):
-            _elem140 = Cart()
+            _elem119 = Cart()
-            _elem140.read(iprot)
+            _elem119.read(iprot)
-            self.success.append(_elem140)
+            self.success.append(_elem119)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCartsByTime_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter141 in self.success:
+      for iter120 in self.success:
-        iter141.write(oprot)
+        iter120.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.scx is not None:
       oprot.writeFieldBegin('scx', TType.STRUCT, 1)
       self.scx.write(oprot)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class changeCartStatus_args:
-  """
-  Attributes:
-   - cartId
-   - status
-  """
-  thrift_spec = (
-    None, # 0
-    (1, TType.I64, 'cartId', None, None, ), # 1
-    (2, TType.I32, 'status', None, None, ), # 2
-  )
-  def __init__(self, cartId=None, status=None,):
-    self.cartId = cartId
-    self.status = status
-  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.cartId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I32:
-          self.status = iprot.readI32();
-        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('changeCartStatus_args')
-    if self.cartId is not None:
-      oprot.writeFieldBegin('cartId', TType.I64, 1)
-      oprot.writeI64(self.cartId)
-      oprot.writeFieldEnd()
-    if self.status is not None:
-      oprot.writeFieldBegin('status', TType.I32, 2)
-      oprot.writeI32(self.status)
-      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 changeCartStatus_result:
-  """
-  Attributes:
-   - scx
-  """
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
-  )
-  def __init__(self, scx=None,):
-    self.scx = scx
-  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.scx = ShoppingCartException()
-          self.scx.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('changeCartStatus_result')
-    if self.scx is not None:
-      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.scx.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 addItemToCart_args:
   """
   Attributes:
    - cartId
    - itemId
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.discounts = []
-          (_etype145, _size142) = iprot.readListBegin()
+          (_etype124, _size121) = iprot.readListBegin()
-          for _i146 in xrange(_size142):
+          for _i125 in xrange(_size121):
-            _elem147 = Discount()
+            _elem126 = Discount()
-            _elem147.read(iprot)
+            _elem126.read(iprot)
-            self.discounts.append(_elem147)
+            self.discounts.append(_elem126)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('saveDiscounts_args')
     if self.discounts is not None:
       oprot.writeFieldBegin('discounts', TType.LIST, 1)
       oprot.writeListBegin(TType.STRUCT, len(self.discounts))
-      for iter148 in self.discounts:
+      for iter127 in self.discounts:
-        iter148.write(oprot)
+        iter127.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
    - cartId
    - sessionSource
    - sessionStartTime
    - firstSource
    - firstSourceTime
+   - userId
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'cartId', None, None, ), # 1
     (2, TType.STRING, 'sessionSource', None, None, ), # 2
     (3, TType.I64, 'sessionStartTime', None, None, ), # 3
     (4, TType.STRING, 'firstSource', None, None, ), # 4
     (5, TType.I64, 'firstSourceTime', None, None, ), # 5
+    (6, TType.I64, 'userId', None, None, ), # 6
+  )
-  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None,):
+  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None,):
     self.cartId = cartId
     self.sessionSource = sessionSource
     self.sessionStartTime = sessionStartTime
     self.firstSource = firstSource
     self.firstSourceTime = firstSourceTime
+    self.userId = userId
   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 == 5:
         if ftype == TType.I64:
           self.firstSourceTime = iprot.readI64();
         else:
           iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
       oprot.writeFieldEnd()
     if self.firstSourceTime is not None:
       oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
       oprot.writeI64(self.firstSourceTime)
       oprot.writeFieldEnd()
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 6)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.items = {}
-          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
+          (_ktype129, _vtype130, _size128 ) = iprot.readMapBegin()
-          for _i153 in xrange(_size149):
+          for _i132 in xrange(_size128):
-            _key154 = iprot.readI64();
+            _key133 = iprot.readI64();
-            _val155 = iprot.readDouble();
+            _val134 = iprot.readDouble();
-            self.items[_key154] = _val155
+            self.items[_key133] = _val134
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.cartId)
       oprot.writeFieldEnd()
     if self.items is not None:
       oprot.writeFieldBegin('items', TType.MAP, 2)
       oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
-      for kiter156,viter157 in self.items.items():
+      for kiter135,viter136 in self.items.items():
-        oprot.writeI64(kiter156)
+        oprot.writeI64(kiter135)
-        oprot.writeDouble(viter157)
+        oprot.writeDouble(viter136)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype161, _size158) = iprot.readListBegin()
+          (_etype140, _size137) = iprot.readListBegin()
-          for _i162 in xrange(_size158):
+          for _i141 in xrange(_size137):
-            _elem163 = User()
+            _elem142 = User()
-            _elem163.read(iprot)
+            _elem142.read(iprot)
-            self.success.append(_elem163)
+            self.success.append(_elem142)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllUsers_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter164 in self.success:
+      for iter143 in self.success:
-        iter164.write(oprot)
+        iter143.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype168, _size165) = iprot.readListBegin()
+          (_etype147, _size144) = iprot.readListBegin()
-          for _i169 in xrange(_size165):
+          for _i148 in xrange(_size144):
-            _elem170 = UserNote()
+            _elem149 = UserNote()
-            _elem170.read(iprot)
+            _elem149.read(iprot)
-            self.success.append(_elem170)
+            self.success.append(_elem149)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getUserNotes_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter171 in self.success:
+      for iter150 in self.success:
-        iter171.write(oprot)
+        iter150.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype175, _size172) = iprot.readListBegin()
+          (_etype154, _size151) = iprot.readListBegin()
-          for _i176 in xrange(_size172):
+          for _i155 in xrange(_size151):
-            _elem177 = iprot.readI64();
+            _elem156 = iprot.readI64();
-            self.success.append(_elem177)
+            self.success.append(_elem156)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getMyResearchItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter178 in self.success:
+      for iter157 in self.success:
-        oprot.writeI64(iter178)
+        oprot.writeI64(iter157)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.scx is not None:
       oprot.writeFieldBegin('scx', TType.STRUCT, 1)
       self.scx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype182, _size179) = iprot.readListBegin()
+          (_etype161, _size158) = iprot.readListBegin()
-          for _i183 in xrange(_size179):
+          for _i162 in xrange(_size158):
-            _elem184 = iprot.readI64();
+            _elem163 = iprot.readI64();
-            self.success.append(_elem184)
+            self.success.append(_elem163)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getBrowseHistoryItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter185 in self.success:
+      for iter164 in self.success:
-        oprot.writeI64(iter185)
+        oprot.writeI64(iter164)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.scx is not None:
       oprot.writeFieldBegin('scx', TType.STRUCT, 1)
       self.scx.write(oprot)

Subversion Repositories SmartDukaan

(root)//trunk/PyProj/src/shop2020/thriftpy/model/v1/user/UserContextService.py – Rev 4668 → 5326