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

 class Iface:
   """
   service
   """
-  def createContext(self, context, updateExisting):
+  def createAnonymousUser(self, jsessionId):
     """
     Parameters:
-     - context
-     - updateExisting
+     - jsessionId
     """
     pass
-  def getContextFromId(self, userId, isSessionId):
+  def getUserById(self, userId):
     """
     Parameters:
      - userId
-     - isSessionId
     """
     pass
-  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
+  def createUser(self, user):
     """
     Parameters:
-     - emailorhandle
-     - isEmail
+     - user
     """
     pass
-  def getState(self, userId, isSessionId):
+  def updateUser(self, user):
     """
     Parameters:
-     - userId
+     - user
-     - isSessionId
     """
     pass
-  def getPrimaryInfo(self, userId, isSessionId):
+  def deleteUser(self, userId):
     """
     Parameters:
      - userId
-     - isSessionId
     """
     pass
-  def getInternalInfo(self, userId, isSessionId):
+  def getUserState(self, userId):
     """
     Parameters:
      - userId
-     - isSessionId
     """
     pass
-  def getContext(self, email, password):
+  def authenticateUser(self, email, password):
     """
     Parameters:
      - email
      - password
     """
     pass
-  def authenticateUser(self, handle, password, isEmail):
-    """
-    Parameters:
-     - handle
-     - password
-     - isEmail
-    """
-    pass
   def userExists(self, email):
     """
     Parameters:
      - email
     """
     pass
-  def addIpAdressForUser(self, ip, timestamp, userId):
+  def addAddressForUser(self, userId, address, timestamp, setDefault):
     """
     Parameters:
-     - ip
-     - timestamp
      - userId
-    """
-    pass
-  def addAddressForUser(self, address, userid, timestamp, setDefault):
-    """
-    Parameters:
      - address
-     - userid
      - timestamp
      - setDefault
     """
     pass
      - userid
      - password
     """
     pass
-  def deleteUser(self, userid, isSessionId):
+  def createCart(self, userId):
     """
     Parameters:
-     - userid
+     - userId
-     - isSessionId
     """
     pass
-  def sendEmailVerification(self, userid):
+  def getCurrentCart(self, userId):
     """
     Parameters:
-     - userid
+     - userId
     """
     pass
-  def sendSMSVerification(self, userid):
+  def getCart(self, cartId):
     """
     Parameters:
-     - userid
+     - cartId
     """
     pass
-  def confirmEmailVerification(self, userid):
+  def getCartsForUser(self, userId, status):
     """
     Parameters:
-     - userid
+     - userId
+     - status
     """
     pass
-  def confirmSMSVerification(self, userid):
+  def getCartsByStatus(self, status):
     """
     Parameters:
-     - userid
+     - status
     """
     pass
-  def addSocialhandle(self, userid, socialService, handle):
+  def getCartsByTime(self, from_time, to_time, status):
     """
     Parameters:
-     - userid
+     - from_time
-     - socialService
+     - to_time
-     - handle
+     - status
     """
     pass
-  def sendNewPasswordById(self, userid):
+  def changeCartStatus(self, cartId, status):
     """
     Parameters:
+     - cartId
+     - status
+    """
+    pass
+  def addItemToCart(self, cartId, itemId, quantity):
+    """
+    Parameters:
+     - cartId
+     - itemId
+     - quantity
+    """
+    pass
+  def deleteItemFromCart(self, cartId, itemId):
+    """
+    Parameters:
+     - cartId
+     - itemId
+    """
+    pass
+  def changeQuantity(self, cartId, itemId, quantity):
+    """
+    Parameters:
+     - cartId
+     - itemId
+     - quantity
+    """
+    pass
+  def changeItemStatus(self, cartId, itemId, status):
+    """
+    Parameters:
+     - cartId
-     - userid
+     - itemId
+     - status
+    """
+    pass
+  def addAddressToCart(self, cartId, addressId):
+    """
+    Parameters:
+     - cartId
+     - addressId
+    """
+    pass
+  def commitCart(self, cartId):
+    """
+    Parameters:
+     - cartId
+    """
+    pass
+  def validateCart(self, cartId):
+    """
+    Parameters:
+     - cartId
     """
     pass
-  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
+  def mergeCart(self, fromCartId, toCartId):
     """
     Parameters:
+     - fromCartId
+     - toCartId
+    """
+    pass
+  def addWidget(self, widget):
+    """
+    Parameters:
+     - widget
+    """
+    pass
+  def addItemToWidget(self, widget_id, items):
+    """
+    Parameters:
+     - widget_id
+     - items
+    """
+    pass
+  def deleteItemFromWidget(self, widget_id, item_id):
+    """
+    Parameters:
+     - widget_id
+     - item_id
+    """
+    pass
+  def updateWidget(self, widgetId, enable):
+    """
+    Parameters:
+     - widgetId
+     - enable
+    """
+    pass
+  def updateWidgetItem(self, widgetId, enable):
+    """
+    Parameters:
+     - widgetId
+     - enable
+    """
+    pass
+  def getWidget(self, type, userId, onlyEnabled):
+    """
+    Parameters:
+     - type
+     - userId
-     - emailOrHandle
+     - onlyEnabled
+    """
+    pass
+  def getMyResearch(self, user_id):
+    """
+    Parameters:
+     - user_id
+    """
+    pass
+  def updateMyResearch(self, user_id, item_id):
+    """
+    Parameters:
+     - user_id
+     - item_id
+    """
+    pass
+  def deleteItemFromMyResearch(self, user_id, item_id):
+    """
+    Parameters:
+     - user_id
+     - item_id
+    """
+    pass
+  def updateRatings(self, item_id, type, rating, user_id):
+    """
+    Parameters:
+     - item_id
+     - type
+     - rating
+     - user_id
+    """
+    pass
+  def getRatings(self, item_id, user_id):
+    """
+    Parameters:
+     - item_id
+     - user_id
+    """
+    pass
+  def updateBrowseHistory(self, user_id, item_id, isSessionId):
+    """
+    Parameters:
+     - user_id
-     - isEmail
+     - item_id
+     - isSessionId
+    """
+    pass
+  def getBrowseHistory(self, userId, isSessionId):
+    """
+    Parameters:
+     - userId
+     - isSessionId
     """
     pass
 class Client(Iface):
     self._iprot = self._oprot = iprot
     if oprot != None:
       self._oprot = oprot
     self._seqid = 0
-  def createContext(self, context, updateExisting):
+  def createAnonymousUser(self, jsessionId):
     """
     Parameters:
-     - context
-     - updateExisting
+     - jsessionId
     """
-    self.send_createContext(context, updateExisting)
+    self.send_createAnonymousUser(jsessionId)
-    return self.recv_createContext()
+    return self.recv_createAnonymousUser()
-  def send_createContext(self, context, updateExisting):
+  def send_createAnonymousUser(self, jsessionId):
-    self._oprot.writeMessageBegin('createContext', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
-    args = createContext_args()
+    args = createAnonymousUser_args()
-    args.context = context
-    args.updateExisting = updateExisting
+    args.jsessionId = jsessionId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_createContext(self, ):
+  def recv_createAnonymousUser(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = createContext_result()
+    result = createAnonymousUser_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.cex != None:
+    if result.ucex != None:
-      raise result.cex
+      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "createContext failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
-  def getContextFromId(self, userId, isSessionId):
+  def getUserById(self, userId):
     """
     Parameters:
      - userId
-     - isSessionId
     """
-    self.send_getContextFromId(userId, isSessionId)
+    self.send_getUserById(userId)
-    return self.recv_getContextFromId()
+    return self.recv_getUserById()
-  def send_getContextFromId(self, userId, isSessionId):
+  def send_getUserById(self, userId):
-    self._oprot.writeMessageBegin('getContextFromId', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
-    args = getContextFromId_args()
+    args = getUserById_args()
     args.userId = userId
-    args.isSessionId = isSessionId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getContextFromId(self, ):
+  def recv_getUserById(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getContextFromId_result()
+    result = getUserById_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.ucex != None:
-      raise result.ucx
+      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromId failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
-  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
+  def createUser(self, user):
     """
     Parameters:
-     - emailorhandle
-     - isEmail
+     - user
     """
-    self.send_getContextFromEmailOrHandle(emailorhandle, isEmail)
+    self.send_createUser(user)
-    return self.recv_getContextFromEmailOrHandle()
+    return self.recv_createUser()
-  def send_getContextFromEmailOrHandle(self, emailorhandle, isEmail):
+  def send_createUser(self, user):
-    self._oprot.writeMessageBegin('getContextFromEmailOrHandle', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
-    args = getContextFromEmailOrHandle_args()
+    args = createUser_args()
-    args.emailorhandle = emailorhandle
-    args.isEmail = isEmail
+    args.user = user
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getContextFromEmailOrHandle(self, ):
+  def recv_createUser(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getContextFromEmailOrHandle_result()
+    result = createUser_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.ucex != None:
-      raise result.ucx
+      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromEmailOrHandle failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
-  def getState(self, userId, isSessionId):
+  def updateUser(self, user):
     """
     Parameters:
-     - userId
+     - user
-     - isSessionId
     """
-    self.send_getState(userId, isSessionId)
+    self.send_updateUser(user)
-    return self.recv_getState()
+    return self.recv_updateUser()
-  def send_getState(self, userId, isSessionId):
+  def send_updateUser(self, user):
-    self._oprot.writeMessageBegin('getState', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
-    args = getState_args()
+    args = updateUser_args()
-    args.userId = userId
+    args.user = user
-    args.isSessionId = isSessionId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getState(self, ):
+  def recv_updateUser(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getState_result()
+    result = updateUser_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.ucex != None:
-      raise result.ucx
+      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getState failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
-  def getPrimaryInfo(self, userId, isSessionId):
+  def deleteUser(self, userId):
     """
     Parameters:
      - userId
-     - isSessionId
     """
-    self.send_getPrimaryInfo(userId, isSessionId)
+    self.send_deleteUser(userId)
-    return self.recv_getPrimaryInfo()
+    return self.recv_deleteUser()
-  def send_getPrimaryInfo(self, userId, isSessionId):
+  def send_deleteUser(self, userId):
-    self._oprot.writeMessageBegin('getPrimaryInfo', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
-    args = getPrimaryInfo_args()
+    args = deleteUser_args()
     args.userId = userId
-    args.isSessionId = isSessionId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getPrimaryInfo(self, ):
+  def recv_deleteUser(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getPrimaryInfo_result()
+    result = deleteUser_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.ucex != None:
-      raise result.ucx
+      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrimaryInfo failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
-  def getInternalInfo(self, userId, isSessionId):
+  def getUserState(self, userId):
     """
     Parameters:
      - userId
-     - isSessionId
     """
-    self.send_getInternalInfo(userId, isSessionId)
+    self.send_getUserState(userId)
-    return self.recv_getInternalInfo()
+    return self.recv_getUserState()
-  def send_getInternalInfo(self, userId, isSessionId):
+  def send_getUserState(self, userId):
-    self._oprot.writeMessageBegin('getInternalInfo', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
-    args = getInternalInfo_args()
+    args = getUserState_args()
     args.userId = userId
-    args.isSessionId = isSessionId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getInternalInfo(self, ):
+  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 = getInternalInfo_result()
+    result = getUserState_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.ucex != None:
-      raise result.ucx
+      raise result.ucex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInternalInfo failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
-  def getContext(self, email, password):
+  def authenticateUser(self, email, password):
     """
     Parameters:
      - email
      - password
     """
-    self.send_getContext(email, password)
-    return self.recv_getContext()
-  def send_getContext(self, email, password):
-    self._oprot.writeMessageBegin('getContext', TMessageType.CALL, self._seqid)
-    args = getContext_args()
-    args.email = email
-    args.password = password
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_getContext(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getContext_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ax != None:
-      raise result.ax
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContext failed: unknown result");
-  def authenticateUser(self, handle, password, isEmail):
-    """
-    Parameters:
-     - handle
-     - password
-     - isEmail
-    """
-    self.send_authenticateUser(handle, password, isEmail)
+    self.send_authenticateUser(email, password)
     return self.recv_authenticateUser()
-  def send_authenticateUser(self, handle, password, isEmail):
+  def send_authenticateUser(self, email, password):
     self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
     args = authenticateUser_args()
-    args.handle = handle
+    args.email = email
     args.password = password
-    args.isEmail = isEmail
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_authenticateUser(self, ):
     result = authenticateUser_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ax != None:
+    if result.auex != None:
-      raise result.ax
+      raise result.auex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
   def userExists(self, email):
     """
     Parameters:
       return result.success
     if result.ucx != None:
       raise result.ucx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
-  def addIpAdressForUser(self, ip, timestamp, userId):
+  def addAddressForUser(self, userId, address, timestamp, setDefault):
     """
     Parameters:
-     - ip
-     - timestamp
      - userId
-    """
-    self.send_addIpAdressForUser(ip, timestamp, userId)
-    return self.recv_addIpAdressForUser()
-  def send_addIpAdressForUser(self, ip, timestamp, userId):
-    self._oprot.writeMessageBegin('addIpAdressForUser', TMessageType.CALL, self._seqid)
-    args = addIpAdressForUser_args()
-    args.ip = ip
-    args.timestamp = timestamp
-    args.userId = userId
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_addIpAdressForUser(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = addIpAdressForUser_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ucx != None:
-      raise result.ucx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "addIpAdressForUser failed: unknown result");
-  def addAddressForUser(self, address, userid, timestamp, setDefault):
-    """
-    Parameters:
      - address
-     - userid
      - timestamp
      - setDefault
     """
-    self.send_addAddressForUser(address, userid, timestamp, setDefault)
+    self.send_addAddressForUser(userId, address, timestamp, setDefault)
     return self.recv_addAddressForUser()
-  def send_addAddressForUser(self, address, userid, timestamp, setDefault):
+  def send_addAddressForUser(self, userId, address, timestamp, setDefault):
     self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
     args = addAddressForUser_args()
+    args.userId = userId
     args.address = address
-    args.userid = userid
     args.timestamp = timestamp
     args.setDefault = setDefault
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
       return result.success
     if result.ucx != None:
       raise result.ucx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
-  def deleteUser(self, userid, isSessionId):
+  def createCart(self, userId):
     """
     Parameters:
-     - userid
+     - userId
-     - isSessionId
     """
-    self.send_deleteUser(userid, isSessionId)
+    self.send_createCart(userId)
-    return self.recv_deleteUser()
+    return self.recv_createCart()
-  def send_deleteUser(self, userid, isSessionId):
+  def send_createCart(self, userId):
-    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
-    args = deleteUser_args()
+    args = createCart_args()
-    args.userid = userid
+    args.userId = userId
-    args.isSessionId = isSessionId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_deleteUser(self, ):
+  def recv_createCart(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = deleteUser_result()
+    result = createCart_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
-  def sendEmailVerification(self, userid):
+  def getCurrentCart(self, userId):
     """
     Parameters:
-     - userid
+     - userId
     """
-    self.send_sendEmailVerification(userid)
+    self.send_getCurrentCart(userId)
-    return self.recv_sendEmailVerification()
+    return self.recv_getCurrentCart()
-  def send_sendEmailVerification(self, userid):
+  def send_getCurrentCart(self, userId):
-    self._oprot.writeMessageBegin('sendEmailVerification', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
-    args = sendEmailVerification_args()
+    args = getCurrentCart_args()
-    args.userid = userid
+    args.userId = userId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_sendEmailVerification(self, ):
+  def recv_getCurrentCart(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = sendEmailVerification_result()
+    result = getCurrentCart_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendEmailVerification failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
-  def sendSMSVerification(self, userid):
+  def getCart(self, cartId):
     """
     Parameters:
-     - userid
+     - cartId
     """
-    self.send_sendSMSVerification(userid)
+    self.send_getCart(cartId)
-    return self.recv_sendSMSVerification()
+    return self.recv_getCart()
-  def send_sendSMSVerification(self, userid):
+  def send_getCart(self, cartId):
-    self._oprot.writeMessageBegin('sendSMSVerification', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
-    args = sendSMSVerification_args()
+    args = getCart_args()
-    args.userid = userid
+    args.cartId = cartId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_sendSMSVerification(self, ):
+  def recv_getCart(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = sendSMSVerification_result()
+    result = getCart_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendSMSVerification failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
-  def confirmEmailVerification(self, userid):
+  def getCartsForUser(self, userId, status):
     """
     Parameters:
-     - userid
+     - userId
+     - status
     """
-    self.send_confirmEmailVerification(userid)
+    self.send_getCartsForUser(userId, status)
-    return self.recv_confirmEmailVerification()
+    return self.recv_getCartsForUser()
-  def send_confirmEmailVerification(self, userid):
+  def send_getCartsForUser(self, userId, status):
-    self._oprot.writeMessageBegin('confirmEmailVerification', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
-    args = confirmEmailVerification_args()
+    args = getCartsForUser_args()
-    args.userid = userid
+    args.userId = userId
+    args.status = status
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_confirmEmailVerification(self, ):
+  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 = confirmEmailVerification_result()
+    result = getCartsForUser_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmEmailVerification failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
-  def confirmSMSVerification(self, userid):
+  def getCartsByStatus(self, status):
     """
     Parameters:
-     - userid
+     - status
     """
-    self.send_confirmSMSVerification(userid)
+    self.send_getCartsByStatus(status)
-    return self.recv_confirmSMSVerification()
+    return self.recv_getCartsByStatus()
-  def send_confirmSMSVerification(self, userid):
+  def send_getCartsByStatus(self, status):
-    self._oprot.writeMessageBegin('confirmSMSVerification', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
-    args = confirmSMSVerification_args()
+    args = getCartsByStatus_args()
-    args.userid = userid
+    args.status = status
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_confirmSMSVerification(self, ):
+  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 = confirmSMSVerification_result()
+    result = getCartsByStatus_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmSMSVerification failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
+  def getCartsByTime(self, from_time, to_time, status):
+    """
+    Parameters:
+     - from_time
+     - to_time
+     - status
+    """
+    self.send_getCartsByTime(from_time, to_time, status)
+    return self.recv_getCartsByTime()
+  def send_getCartsByTime(self, from_time, to_time, status):
+    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
+    args = getCartsByTime_args()
+    args.from_time = from_time
+    args.to_time = to_time
+    args.status = status
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getCartsByTime(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getCartsByTime_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.scx != None:
+      raise result.scx
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
-  def addSocialhandle(self, userid, socialService, handle):
+  def changeCartStatus(self, cartId, status):
     """
     Parameters:
-     - userid
+     - cartId
-     - socialService
-     - handle
+     - status
     """
-    self.send_addSocialhandle(userid, socialService, handle)
+    self.send_changeCartStatus(cartId, status)
-    return self.recv_addSocialhandle()
+    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 != None:
+      raise result.scx
+    return
+  def addItemToCart(self, cartId, itemId, quantity):
+    """
+    Parameters:
+     - cartId
+     - itemId
+     - quantity
+    """
+    self.send_addItemToCart(cartId, itemId, quantity)
+    self.recv_addItemToCart()
-  def send_addSocialhandle(self, userid, socialService, handle):
+  def send_addItemToCart(self, cartId, itemId, quantity):
-    self._oprot.writeMessageBegin('addSocialhandle', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
-    args = addSocialhandle_args()
+    args = addItemToCart_args()
-    args.userid = userid
+    args.cartId = cartId
-    args.socialService = socialService
+    args.itemId = itemId
-    args.handle = handle
+    args.quantity = quantity
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_addSocialhandle(self, ):
+  def recv_addItemToCart(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = addSocialhandle_result()
+    result = addItemToCart_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def deleteItemFromCart(self, cartId, itemId):
+    """
+    Parameters:
+     - cartId
+     - itemId
+    """
+    self.send_deleteItemFromCart(cartId, itemId)
+    self.recv_deleteItemFromCart()
+  def send_deleteItemFromCart(self, cartId, itemId):
+    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
+    args = deleteItemFromCart_args()
+    args.cartId = cartId
+    args.itemId = itemId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_deleteItemFromCart(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteItemFromCart_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def changeQuantity(self, cartId, itemId, quantity):
+    """
+    Parameters:
+     - cartId
+     - itemId
+     - quantity
+    """
+    self.send_changeQuantity(cartId, itemId, quantity)
+    self.recv_changeQuantity()
+  def send_changeQuantity(self, cartId, itemId, quantity):
+    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
+    args = changeQuantity_args()
+    args.cartId = cartId
+    args.itemId = itemId
+    args.quantity = quantity
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_changeQuantity(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = changeQuantity_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def changeItemStatus(self, cartId, itemId, status):
+    """
+    Parameters:
+     - cartId
+     - itemId
+     - status
+    """
+    self.send_changeItemStatus(cartId, itemId, status)
+    self.recv_changeItemStatus()
+  def send_changeItemStatus(self, cartId, itemId, status):
+    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
+    args = changeItemStatus_args()
+    args.cartId = cartId
+    args.itemId = itemId
+    args.status = status
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_changeItemStatus(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = changeItemStatus_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def addAddressToCart(self, cartId, addressId):
+    """
+    Parameters:
+     - cartId
+     - addressId
+    """
+    self.send_addAddressToCart(cartId, addressId)
+    self.recv_addAddressToCart()
+  def send_addAddressToCart(self, cartId, addressId):
+    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
+    args = addAddressToCart_args()
+    args.cartId = cartId
+    args.addressId = addressId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_addAddressToCart(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = addAddressToCart_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def commitCart(self, cartId):
+    """
+    Parameters:
+     - cartId
+    """
+    self.send_commitCart(cartId)
+    return self.recv_commitCart()
+  def send_commitCart(self, cartId):
+    self._oprot.writeMessageBegin('commitCart', TMessageType.CALL, self._seqid)
+    args = commitCart_args()
+    args.cartId = cartId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_commitCart(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = commitCart_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSocialhandle failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "commitCart failed: unknown result");
-  def sendNewPasswordById(self, userid):
+  def validateCart(self, cartId):
     """
     Parameters:
-     - userid
+     - cartId
     """
-    self.send_sendNewPasswordById(userid)
+    self.send_validateCart(cartId)
-    return self.recv_sendNewPasswordById()
+    return self.recv_validateCart()
-  def send_sendNewPasswordById(self, userid):
+  def send_validateCart(self, cartId):
-    self._oprot.writeMessageBegin('sendNewPasswordById', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
-    args = sendNewPasswordById_args()
+    args = validateCart_args()
-    args.userid = userid
+    args.cartId = cartId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_sendNewPasswordById(self, ):
+  def recv_validateCart(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = sendNewPasswordById_result()
+    result = validateCart_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
+  def mergeCart(self, fromCartId, toCartId):
+    """
+    Parameters:
+     - fromCartId
+     - toCartId
+    """
+    self.send_mergeCart(fromCartId, toCartId)
+    self.recv_mergeCart()
+  def send_mergeCart(self, fromCartId, toCartId):
+    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
+    args = mergeCart_args()
+    args.fromCartId = fromCartId
+    args.toCartId = toCartId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_mergeCart(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mergeCart_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def addWidget(self, widget):
+    """
+    Parameters:
+     - widget
+    """
+    self.send_addWidget(widget)
+    self.recv_addWidget()
+  def send_addWidget(self, widget):
+    self._oprot.writeMessageBegin('addWidget', TMessageType.CALL, self._seqid)
+    args = addWidget_args()
+    args.widget = widget
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_addWidget(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = addWidget_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
+    return
+  def addItemToWidget(self, widget_id, items):
+    """
+    Parameters:
+     - widget_id
+     - items
+    """
+    self.send_addItemToWidget(widget_id, items)
+    self.recv_addItemToWidget()
+  def send_addItemToWidget(self, widget_id, items):
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordById failed: unknown result");
+    self._oprot.writeMessageBegin('addItemToWidget', TMessageType.CALL, self._seqid)
+    args = addItemToWidget_args()
+    args.widget_id = widget_id
+    args.items = items
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_addItemToWidget(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = addItemToWidget_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
-  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
+  def deleteItemFromWidget(self, widget_id, item_id):
     """
     Parameters:
-     - emailOrHandle
+     - widget_id
-     - isEmail
+     - item_id
     """
-    self.send_sendNewPasswordByHandle(emailOrHandle, isEmail)
+    self.send_deleteItemFromWidget(widget_id, item_id)
-    return self.recv_sendNewPasswordByHandle()
+    self.recv_deleteItemFromWidget()
-  def send_sendNewPasswordByHandle(self, emailOrHandle, isEmail):
+  def send_deleteItemFromWidget(self, widget_id, item_id):
-    self._oprot.writeMessageBegin('sendNewPasswordByHandle', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('deleteItemFromWidget', TMessageType.CALL, self._seqid)
-    args = sendNewPasswordByHandle_args()
+    args = deleteItemFromWidget_args()
-    args.emailOrHandle = emailOrHandle
+    args.widget_id = widget_id
-    args.isEmail = isEmail
+    args.item_id = item_id
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_sendNewPasswordByHandle(self, ):
+  def recv_deleteItemFromWidget(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = sendNewPasswordByHandle_result()
+    result = deleteItemFromWidget_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def updateWidget(self, widgetId, enable):
+    """
+    Parameters:
+     - widgetId
+     - enable
+    """
+    self.send_updateWidget(widgetId, enable)
+    self.recv_updateWidget()
+  def send_updateWidget(self, widgetId, enable):
+    self._oprot.writeMessageBegin('updateWidget', TMessageType.CALL, self._seqid)
+    args = updateWidget_args()
+    args.widgetId = widgetId
+    args.enable = enable
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateWidget(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateWidget_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def updateWidgetItem(self, widgetId, enable):
+    """
+    Parameters:
+     - widgetId
+     - enable
+    """
+    self.send_updateWidgetItem(widgetId, enable)
+    self.recv_updateWidgetItem()
+  def send_updateWidgetItem(self, widgetId, enable):
+    self._oprot.writeMessageBegin('updateWidgetItem', TMessageType.CALL, self._seqid)
+    args = updateWidgetItem_args()
+    args.widgetId = widgetId
+    args.enable = enable
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateWidgetItem(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateWidgetItem_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.scx != None:
+      raise result.scx
+    return
+  def getWidget(self, type, userId, onlyEnabled):
+    """
+    Parameters:
+     - type
+     - userId
+     - onlyEnabled
+    """
+    self.send_getWidget(type, userId, onlyEnabled)
+    return self.recv_getWidget()
+  def send_getWidget(self, type, userId, onlyEnabled):
+    self._oprot.writeMessageBegin('getWidget', TMessageType.CALL, self._seqid)
+    args = getWidget_args()
+    args.type = type
+    args.userId = userId
+    args.onlyEnabled = onlyEnabled
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getWidget(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getWidget_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
+    if result.scx != None:
+      raise result.scx
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWidget failed: unknown result");
+  def getMyResearch(self, user_id):
+    """
+    Parameters:
+     - user_id
+    """
+    self.send_getMyResearch(user_id)
+    return self.recv_getMyResearch()
+  def send_getMyResearch(self, user_id):
+    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
+    args = getMyResearch_args()
+    args.user_id = user_id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getMyResearch(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getMyResearch_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.scx != None:
+      raise result.scx
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
+  def updateMyResearch(self, user_id, item_id):
+    """
+    Parameters:
+     - user_id
+     - item_id
+    """
+    self.send_updateMyResearch(user_id, item_id)
+    return self.recv_updateMyResearch()
+  def send_updateMyResearch(self, user_id, item_id):
+    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
+    args = updateMyResearch_args()
+    args.user_id = user_id
+    args.item_id = item_id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateMyResearch(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateMyResearch_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.scx != None:
+      raise result.scx
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
+  def deleteItemFromMyResearch(self, user_id, item_id):
+    """
+    Parameters:
+     - user_id
+     - item_id
+    """
+    self.send_deleteItemFromMyResearch(user_id, item_id)
+    self.recv_deleteItemFromMyResearch()
+  def send_deleteItemFromMyResearch(self, user_id, item_id):
+    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
+    args = deleteItemFromMyResearch_args()
+    args.user_id = user_id
+    args.item_id = item_id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_deleteItemFromMyResearch(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteItemFromMyResearch_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
-    if result.ucx != None:
+    if result.scx != None:
-      raise result.ucx
+      raise result.scx
+    return
+  def updateRatings(self, item_id, type, rating, user_id):
+    """
+    Parameters:
+     - item_id
+     - type
+     - rating
+     - user_id
+    """
+    self.send_updateRatings(item_id, type, rating, user_id)
+    self.recv_updateRatings()
+  def send_updateRatings(self, item_id, type, rating, user_id):
+    self._oprot.writeMessageBegin('updateRatings', TMessageType.CALL, self._seqid)
+    args = updateRatings_args()
+    args.item_id = item_id
+    args.type = type
+    args.rating = rating
+    args.user_id = user_id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateRatings(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateRatings_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getRatings(self, item_id, user_id):
+    """
+    Parameters:
+     - item_id
+     - user_id
+    """
+    self.send_getRatings(item_id, user_id)
+    return self.recv_getRatings()
+  def send_getRatings(self, item_id, user_id):
+    self._oprot.writeMessageBegin('getRatings', TMessageType.CALL, self._seqid)
+    args = getRatings_args()
+    args.item_id = item_id
+    args.user_id = user_id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getRatings(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRatings_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.scx != None:
+      raise result.scx
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRatings failed: unknown result");
+  def updateBrowseHistory(self, user_id, item_id, isSessionId):
+    """
+    Parameters:
+     - user_id
+     - item_id
+     - isSessionId
+    """
+    self.send_updateBrowseHistory(user_id, item_id, isSessionId)
+    self.recv_updateBrowseHistory()
+  def send_updateBrowseHistory(self, user_id, item_id, isSessionId):
+    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
+    args = updateBrowseHistory_args()
+    args.user_id = user_id
+    args.item_id = item_id
+    args.isSessionId = isSessionId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateBrowseHistory(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateBrowseHistory_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getBrowseHistory(self, userId, isSessionId):
+    """
+    Parameters:
+     - userId
+     - isSessionId
+    """
+    self.send_getBrowseHistory(userId, isSessionId)
+    return self.recv_getBrowseHistory()
+  def send_getBrowseHistory(self, userId, isSessionId):
+    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
+    args = getBrowseHistory_args()
+    args.userId = userId
+    args.isSessionId = isSessionId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getBrowseHistory(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getBrowseHistory_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    if result.scx != None:
+      raise result.scx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordByHandle failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
 class Processor(Iface, TProcessor):
   def __init__(self, handler):
     self._handler = handler
     self._processMap = {}
-    self._processMap["createContext"] = Processor.process_createContext
+    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
-    self._processMap["getContextFromId"] = Processor.process_getContextFromId
+    self._processMap["getUserById"] = Processor.process_getUserById
-    self._processMap["getContextFromEmailOrHandle"] = Processor.process_getContextFromEmailOrHandle
-    self._processMap["getState"] = Processor.process_getState
+    self._processMap["createUser"] = Processor.process_createUser
-    self._processMap["getPrimaryInfo"] = Processor.process_getPrimaryInfo
+    self._processMap["updateUser"] = Processor.process_updateUser
-    self._processMap["getInternalInfo"] = Processor.process_getInternalInfo
+    self._processMap["deleteUser"] = Processor.process_deleteUser
-    self._processMap["getContext"] = Processor.process_getContext
+    self._processMap["getUserState"] = Processor.process_getUserState
     self._processMap["authenticateUser"] = Processor.process_authenticateUser
     self._processMap["userExists"] = Processor.process_userExists
-    self._processMap["addIpAdressForUser"] = Processor.process_addIpAdressForUser
     self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
     self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
     self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
     self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
     self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
     self._processMap["updatePassword"] = Processor.process_updatePassword
-    self._processMap["deleteUser"] = Processor.process_deleteUser
+    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["sendEmailVerification"] = Processor.process_sendEmailVerification
+    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
-    self._processMap["sendSMSVerification"] = Processor.process_sendSMSVerification
+    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
-    self._processMap["confirmEmailVerification"] = Processor.process_confirmEmailVerification
+    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
+    self._processMap["addItemToCart"] = Processor.process_addItemToCart
+    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
+    self._processMap["changeQuantity"] = Processor.process_changeQuantity
-    self._processMap["confirmSMSVerification"] = Processor.process_confirmSMSVerification
+    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
+    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
+    self._processMap["commitCart"] = Processor.process_commitCart
+    self._processMap["validateCart"] = Processor.process_validateCart
+    self._processMap["mergeCart"] = Processor.process_mergeCart
-    self._processMap["addSocialhandle"] = Processor.process_addSocialhandle
+    self._processMap["addWidget"] = Processor.process_addWidget
+    self._processMap["addItemToWidget"] = Processor.process_addItemToWidget
+    self._processMap["deleteItemFromWidget"] = Processor.process_deleteItemFromWidget
+    self._processMap["updateWidget"] = Processor.process_updateWidget
+    self._processMap["updateWidgetItem"] = Processor.process_updateWidgetItem
+    self._processMap["getWidget"] = Processor.process_getWidget
+    self._processMap["getMyResearch"] = Processor.process_getMyResearch
-    self._processMap["sendNewPasswordById"] = Processor.process_sendNewPasswordById
+    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
+    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
+    self._processMap["updateRatings"] = Processor.process_updateRatings
+    self._processMap["getRatings"] = Processor.process_getRatings
+    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
-    self._processMap["sendNewPasswordByHandle"] = Processor.process_sendNewPasswordByHandle
+    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
   def process(self, iprot, oprot):
     (name, type, seqid) = iprot.readMessageBegin()
     if name not in self._processMap:
       iprot.skip(TType.STRUCT)
       return
     else:
       self._processMap[name](self, seqid, iprot, oprot)
     return True
-  def process_createContext(self, seqid, iprot, oprot):
+  def process_createAnonymousUser(self, seqid, iprot, oprot):
-    args = createContext_args()
+    args = createAnonymousUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = createContext_result()
+    result = createAnonymousUser_result()
     try:
-      result.success = self._handler.createContext(args.context, args.updateExisting)
+      result.success = self._handler.createAnonymousUser(args.jsessionId)
-    except UserContextException, cex:
+    except UserContextException, ucex:
-      result.cex = cex
+      result.ucex = ucex
-    oprot.writeMessageBegin("createContext", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getContextFromId(self, seqid, iprot, oprot):
+  def process_getUserById(self, seqid, iprot, oprot):
-    args = getContextFromId_args()
+    args = getUserById_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getContextFromId_result()
+    result = getUserById_result()
     try:
-      result.success = self._handler.getContextFromId(args.userId, args.isSessionId)
+      result.success = self._handler.getUserById(args.userId)
-    except UserContextException, ucx:
+    except UserContextException, ucex:
-      result.ucx = ucx
+      result.ucex = ucex
-    oprot.writeMessageBegin("getContextFromId", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getContextFromEmailOrHandle(self, seqid, iprot, oprot):
+  def process_createUser(self, seqid, iprot, oprot):
-    args = getContextFromEmailOrHandle_args()
+    args = createUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getContextFromEmailOrHandle_result()
+    result = createUser_result()
     try:
-      result.success = self._handler.getContextFromEmailOrHandle(args.emailorhandle, args.isEmail)
+      result.success = self._handler.createUser(args.user)
-    except UserContextException, ucx:
+    except UserContextException, ucex:
-      result.ucx = ucx
+      result.ucex = ucex
-    oprot.writeMessageBegin("getContextFromEmailOrHandle", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getState(self, seqid, iprot, oprot):
+  def process_updateUser(self, seqid, iprot, oprot):
-    args = getState_args()
+    args = updateUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getState_result()
+    result = updateUser_result()
     try:
-      result.success = self._handler.getState(args.userId, args.isSessionId)
+      result.success = self._handler.updateUser(args.user)
-    except UserContextException, ucx:
+    except UserContextException, ucex:
-      result.ucx = ucx
+      result.ucex = ucex
-    oprot.writeMessageBegin("getState", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getPrimaryInfo(self, seqid, iprot, oprot):
-    args = getPrimaryInfo_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getPrimaryInfo_result()
-    try:
-      result.success = self._handler.getPrimaryInfo(args.userId, args.isSessionId)
-    except UserContextException, ucx:
-      result.ucx = ucx
-    oprot.writeMessageBegin("getPrimaryInfo", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-  def process_getInternalInfo(self, seqid, iprot, oprot):
+  def process_deleteUser(self, seqid, iprot, oprot):
-    args = getInternalInfo_args()
+    args = deleteUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getInternalInfo_result()
+    result = deleteUser_result()
     try:
-      result.success = self._handler.getInternalInfo(args.userId, args.isSessionId)
+      result.success = self._handler.deleteUser(args.userId)
-    except UserContextException, ucx:
+    except UserContextException, ucex:
-      result.ucx = ucx
+      result.ucex = ucex
-    oprot.writeMessageBegin("getInternalInfo", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getContext(self, seqid, iprot, oprot):
+  def process_getUserState(self, seqid, iprot, oprot):
-    args = getContext_args()
+    args = getUserState_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getContext_result()
+    result = getUserState_result()
     try:
-      result.success = self._handler.getContext(args.email, args.password)
+      result.success = self._handler.getUserState(args.userId)
-    except AuthenticationException, ax:
+    except UserContextException, ucex:
-      result.ax = ax
+      result.ucex = ucex
-    oprot.writeMessageBegin("getContext", TMessageType.REPLY, seqid)
+    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()
     try:
-      result.success = self._handler.authenticateUser(args.handle, args.password, args.isEmail)
+      result.success = self._handler.authenticateUser(args.email, args.password)
-    except AuthenticationException, ax:
+    except AuthenticationException, auex:
-      result.ax = ax
+      result.auex = auex
     oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_addIpAdressForUser(self, seqid, iprot, oprot):
-    args = addIpAdressForUser_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addIpAdressForUser_result()
-    try:
-      result.success = self._handler.addIpAdressForUser(args.ip, args.timestamp, args.userId)
-    except UserContextException, ucx:
-      result.ucx = ucx
-    oprot.writeMessageBegin("addIpAdressForUser", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_addAddressForUser(self, seqid, iprot, oprot):
     args = addAddressForUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = addAddressForUser_result()
     try:
-      result.success = self._handler.addAddressForUser(args.address, args.userid, args.timestamp, args.setDefault)
+      result.success = self._handler.addAddressForUser(args.userId, args.address, args.timestamp, args.setDefault)
     except UserContextException, ucx:
       result.ucx = ucx
     oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_deleteUser(self, seqid, iprot, oprot):
+  def process_createCart(self, seqid, iprot, oprot):
-    args = deleteUser_args()
+    args = createCart_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = deleteUser_result()
+    result = createCart_result()
     try:
-      result.success = self._handler.deleteUser(args.userid, args.isSessionId)
+      result.success = self._handler.createCart(args.userId)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_sendEmailVerification(self, seqid, iprot, oprot):
+  def process_getCurrentCart(self, seqid, iprot, oprot):
-    args = sendEmailVerification_args()
+    args = getCurrentCart_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = sendEmailVerification_result()
+    result = getCurrentCart_result()
     try:
-      result.success = self._handler.sendEmailVerification(args.userid)
+      result.success = self._handler.getCurrentCart(args.userId)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("sendEmailVerification", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_sendSMSVerification(self, seqid, iprot, oprot):
+  def process_getCart(self, seqid, iprot, oprot):
-    args = sendSMSVerification_args()
+    args = getCart_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = sendSMSVerification_result()
+    result = getCart_result()
     try:
-      result.success = self._handler.sendSMSVerification(args.userid)
+      result.success = self._handler.getCart(args.cartId)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("sendSMSVerification", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_confirmEmailVerification(self, seqid, iprot, oprot):
+  def process_getCartsForUser(self, seqid, iprot, oprot):
-    args = confirmEmailVerification_args()
+    args = getCartsForUser_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = confirmEmailVerification_result()
+    result = getCartsForUser_result()
     try:
-      result.success = self._handler.confirmEmailVerification(args.userid)
+      result.success = self._handler.getCartsForUser(args.userId, args.status)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("confirmEmailVerification", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_confirmSMSVerification(self, seqid, iprot, oprot):
+  def process_getCartsByStatus(self, seqid, iprot, oprot):
-    args = confirmSMSVerification_args()
+    args = getCartsByStatus_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = confirmSMSVerification_result()
+    result = getCartsByStatus_result()
     try:
-      result.success = self._handler.confirmSMSVerification(args.userid)
+      result.success = self._handler.getCartsByStatus(args.status)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("confirmSMSVerification", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_addSocialhandle(self, seqid, iprot, oprot):
+  def process_getCartsByTime(self, seqid, iprot, oprot):
-    args = addSocialhandle_args()
+    args = getCartsByTime_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = addSocialhandle_result()
+    result = getCartsByTime_result()
     try:
-      result.success = self._handler.addSocialhandle(args.userid, args.socialService, args.handle)
+      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("addSocialhandle", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_sendNewPasswordById(self, seqid, iprot, oprot):
+  def process_changeCartStatus(self, seqid, iprot, oprot):
-    args = sendNewPasswordById_args()
+    args = changeCartStatus_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = sendNewPasswordById_result()
+    result = changeCartStatus_result()
     try:
-      result.success = self._handler.sendNewPasswordById(args.userid)
+      self._handler.changeCartStatus(args.cartId, args.status)
-    except UserContextException, ucx:
+    except ShoppingCartException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("sendNewPasswordById", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_sendNewPasswordByHandle(self, seqid, iprot, oprot):
+  def process_addItemToCart(self, seqid, iprot, oprot):
-    args = sendNewPasswordByHandle_args()
+    args = addItemToCart_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = sendNewPasswordByHandle_result()
+    result = addItemToCart_result()
     try:
+      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
+    except ShoppingCartException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_deleteItemFromCart(self, seqid, iprot, oprot):
+    args = deleteItemFromCart_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteItemFromCart_result()
+    try:
+      self._handler.deleteItemFromCart(args.cartId, args.itemId)
+    except ShoppingCartException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_changeQuantity(self, seqid, iprot, oprot):
+    args = changeQuantity_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = changeQuantity_result()
+    try:
+      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
+    except ShoppingCartException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_changeItemStatus(self, seqid, iprot, oprot):
+    args = changeItemStatus_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = changeItemStatus_result()
+    try:
+      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
+    except ShoppingCartException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_addAddressToCart(self, seqid, iprot, oprot):
+    args = addAddressToCart_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addAddressToCart_result()
+    self._handler.addAddressToCart(args.cartId, args.addressId)
+    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_commitCart(self, seqid, iprot, oprot):
+    args = commitCart_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = commitCart_result()
+    try:
+      result.success = self._handler.commitCart(args.cartId)
+    except ShoppingCartException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("commitCart", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_validateCart(self, seqid, iprot, oprot):
+    args = validateCart_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = validateCart_result()
+    result.success = self._handler.validateCart(args.cartId)
+    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_mergeCart(self, seqid, iprot, oprot):
+    args = mergeCart_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = mergeCart_result()
+    self._handler.mergeCart(args.fromCartId, args.toCartId)
+    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_addWidget(self, seqid, iprot, oprot):
+    args = addWidget_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addWidget_result()
+    try:
+      self._handler.addWidget(args.widget)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("addWidget", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_addItemToWidget(self, seqid, iprot, oprot):
+    args = addItemToWidget_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addItemToWidget_result()
+    try:
+      self._handler.addItemToWidget(args.widget_id, args.items)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("addItemToWidget", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_deleteItemFromWidget(self, seqid, iprot, oprot):
+    args = deleteItemFromWidget_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteItemFromWidget_result()
+    try:
+      self._handler.deleteItemFromWidget(args.widget_id, args.item_id)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("deleteItemFromWidget", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateWidget(self, seqid, iprot, oprot):
+    args = updateWidget_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateWidget_result()
+    try:
+      self._handler.updateWidget(args.widgetId, args.enable)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("updateWidget", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateWidgetItem(self, seqid, iprot, oprot):
+    args = updateWidgetItem_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateWidgetItem_result()
+    try:
+      self._handler.updateWidgetItem(args.widgetId, args.enable)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("updateWidgetItem", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getWidget(self, seqid, iprot, oprot):
+    args = getWidget_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getWidget_result()
+    try:
+      result.success = self._handler.getWidget(args.type, args.userId, args.onlyEnabled)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("getWidget", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getMyResearch(self, seqid, iprot, oprot):
+    args = getMyResearch_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getMyResearch_result()
+    try:
+      result.success = self._handler.getMyResearch(args.user_id)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateMyResearch(self, seqid, iprot, oprot):
+    args = updateMyResearch_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateMyResearch_result()
+    try:
-      result.success = self._handler.sendNewPasswordByHandle(args.emailOrHandle, args.isEmail)
+      result.success = self._handler.updateMyResearch(args.user_id, args.item_id)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
+    args = deleteItemFromMyResearch_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteItemFromMyResearch_result()
+    try:
+      self._handler.deleteItemFromMyResearch(args.user_id, args.item_id)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateRatings(self, seqid, iprot, oprot):
+    args = updateRatings_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateRatings_result()
+    self._handler.updateRatings(args.item_id, args.type, args.rating, args.user_id)
+    oprot.writeMessageBegin("updateRatings", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getRatings(self, seqid, iprot, oprot):
+    args = getRatings_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRatings_result()
+    try:
+      result.success = self._handler.getRatings(args.item_id, args.user_id)
+    except WidgetException, scx:
+      result.scx = scx
+    oprot.writeMessageBegin("getRatings", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateBrowseHistory(self, seqid, iprot, oprot):
+    args = updateBrowseHistory_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateBrowseHistory_result()
+    self._handler.updateBrowseHistory(args.user_id, args.item_id, args.isSessionId)
+    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getBrowseHistory(self, seqid, iprot, oprot):
+    args = getBrowseHistory_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getBrowseHistory_result()
+    try:
+      result.success = self._handler.getBrowseHistory(args.userId, args.isSessionId)
-    except UserContextException, ucx:
+    except WidgetException, scx:
-      result.ucx = ucx
+      result.scx = scx
-    oprot.writeMessageBegin("sendNewPasswordByHandle", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 # HELPER FUNCTIONS AND STRUCTURES
-class createContext_args:
+class createAnonymousUser_args:
   """
   Attributes:
-   - context
-   - updateExisting
+   - jsessionId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'context', (UserContext, UserContext.thrift_spec), None, ), # 1
-    (2, TType.BOOL, 'updateExisting', None, None, ), # 2
+    (1, TType.STRING, 'jsessionId', None, None, ), # 1
+  )
-  def __init__(self, context=None, updateExisting=None,):
+  def __init__(self, jsessionId=None,):
-    self.context = context
-    self.updateExisting = updateExisting
+    self.jsessionId = jsessionId
   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.STRING:
-          self.context = UserContext()
-          self.context.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.updateExisting = iprot.readBool();
+          self.jsessionId = 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('createContext_args')
+    oprot.writeStructBegin('createAnonymousUser_args')
-    if self.context != None:
+    if self.jsessionId != None:
-      oprot.writeFieldBegin('context', TType.STRUCT, 1)
+      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
-      self.context.write(oprot)
-      oprot.writeFieldEnd()
-    if self.updateExisting != None:
-      oprot.writeFieldBegin('updateExisting', TType.BOOL, 2)
-      oprot.writeBool(self.updateExisting)
+      oprot.writeString(self.jsessionId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class createContext_result:
+class createAnonymousUser_result:
   """
   Attributes:
    - success
-   - cex
+   - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
+    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'cex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, cex=None,):
+  def __init__(self, success=None, ucex=None,):
     self.success = success
-    self.cex = cex
+    self.ucex = ucex
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.STRUCT:
-          self.success = UserContext()
+          self.success = User()
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.cex = UserContextException()
+          self.ucex = UserContextException()
-          self.cex.read(iprot)
+          self.ucex.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('createContext_result')
+    oprot.writeStructBegin('createAnonymousUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
-    if self.cex != None:
+    if self.ucex != None:
-      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
-      self.cex.write(oprot)
+      self.ucex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getContextFromId_args:
+class getUserById_args:
   """
   Attributes:
    - userId
-   - isSessionId
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'userId', None, None, ), # 1
-    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
+  )
-  def __init__(self, userId=None, isSessionId=None,):
+  def __init__(self, userId=None,):
     self.userId = userId
-    self.isSessionId = isSessionId
   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
       if fid == 1:
         if ftype == TType.I64:
           self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.isSessionId = iprot.readBool();
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('getContextFromId_args')
+    oprot.writeStructBegin('getUserById_args')
     if self.userId != None:
       oprot.writeFieldBegin('userId', TType.I64, 1)
       oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
-    if self.isSessionId != None:
-      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
-      oprot.writeBool(self.isSessionId)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getContextFromId_result:
+class getUserById_result:
   """
   Attributes:
    - success
-   - ucx
+   - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
+    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, ucex=None,):
     self.success = success
-    self.ucx = ucx
+    self.ucex = ucex
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.STRUCT:
-          self.success = UserContext()
+          self.success = User()
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.ucex = UserContextException()
-          self.ucx.read(iprot)
+          self.ucex.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('getContextFromId_result')
+    oprot.writeStructBegin('getUserById_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.ucex != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.ucex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getContextFromEmailOrHandle_args:
+class createUser_args:
   """
   Attributes:
-   - emailorhandle
-   - isEmail
+   - user
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'emailorhandle', None, None, ), # 1
+    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
-    (2, TType.BOOL, 'isEmail', None, None, ), # 2
+  )
-  def __init__(self, emailorhandle=None, isEmail=None,):
+  def __init__(self, user=None,):
-    self.emailorhandle = emailorhandle
-    self.isEmail = isEmail
+    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.STRING:
+        if ftype == TType.STRUCT:
-          self.emailorhandle = iprot.readString();
-        else:
-          iprot.skip(ftype)
+          self.user = User()
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.isEmail = iprot.readBool();
+          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('getContextFromEmailOrHandle_args')
+    oprot.writeStructBegin('createUser_args')
-    if self.emailorhandle != None:
-      oprot.writeFieldBegin('emailorhandle', TType.STRING, 1)
-      oprot.writeString(self.emailorhandle)
-      oprot.writeFieldEnd()
-    if self.isEmail != None:
+    if self.user != None:
-      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
+      oprot.writeFieldBegin('user', TType.STRUCT, 1)
-      oprot.writeBool(self.isEmail)
+      self.user.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getContextFromEmailOrHandle_result:
+class createUser_result:
   """
   Attributes:
    - success
-   - ucx
+   - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
+    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, ucex=None,):
     self.success = success
-    self.ucx = ucx
+    self.ucex = ucex
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.STRUCT:
-          self.success = UserContext()
+          self.success = User()
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.ucex = UserContextException()
-          self.ucx.read(iprot)
+          self.ucex.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('getContextFromEmailOrHandle_result')
+    oprot.writeStructBegin('createUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.ucex != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.ucex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getState_args:
+class updateUser_args:
   """
   Attributes:
-   - userId
+   - user
-   - isSessionId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userId', None, None, ), # 1
+    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
-    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
+  )
-  def __init__(self, userId=None, isSessionId=None,):
+  def __init__(self, user=None,):
-    self.userId = userId
+    self.user = user
-    self.isSessionId = isSessionId
   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()
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.isSessionId = iprot.readBool();
+          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('getState_args')
+    oprot.writeStructBegin('updateUser_args')
-    if self.userId != None:
+    if self.user != None:
-      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeFieldBegin('user', TType.STRUCT, 1)
-      oprot.writeI64(self.userId)
-      oprot.writeFieldEnd()
-    if self.isSessionId != None:
+      self.user.write(oprot)
-      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
-      oprot.writeBool(self.isSessionId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getState_result:
+class updateUser_result:
   """
   Attributes:
    - success
-   - ucx
+   - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
+    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, ucex=None,):
     self.success = success
-    self.ucx = ucx
+    self.ucex = ucex
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.STRUCT:
-          self.success = UserState()
+          self.success = User()
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.ucex = UserContextException()
-          self.ucx.read(iprot)
+          self.ucex.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('getState_result')
+    oprot.writeStructBegin('updateUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.ucex != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.ucex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getPrimaryInfo_args:
+class deleteUser_args:
   """
   Attributes:
    - userId
-   - isSessionId
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'userId', None, None, ), # 1
-    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
+  )
-  def __init__(self, userId=None, isSessionId=None,):
+  def __init__(self, userId=None,):
     self.userId = userId
-    self.isSessionId = isSessionId
   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
       if fid == 1:
         if ftype == TType.I64:
           self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.isSessionId = iprot.readBool();
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('getPrimaryInfo_args')
+    oprot.writeStructBegin('deleteUser_args')
     if self.userId != None:
       oprot.writeFieldBegin('userId', TType.I64, 1)
       oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
-    if self.isSessionId != None:
-      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
-      oprot.writeBool(self.isSessionId)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getPrimaryInfo_result:
+class deleteUser_result:
   """
   Attributes:
    - success
-   - ucx
+   - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserPrimaryInfo, UserPrimaryInfo.thrift_spec), None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, ucex=None,):
     self.success = success
-    self.ucx = ucx
+    self.ucex = ucex
   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 == 0:
-        if ftype == TType.STRUCT:
+        if ftype == TType.BOOL:
-          self.success = UserPrimaryInfo()
+          self.success = iprot.readBool();
-          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.ucex = UserContextException()
-          self.ucx.read(iprot)
+          self.ucex.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('getPrimaryInfo_result')
+    oprot.writeStructBegin('deleteUser_result')
     if self.success != 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.ucx != None:
+    if self.ucex != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.ucex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getInternalInfo_args:
+class getUserState_args:
   """
   Attributes:
    - userId
-   - isSessionId
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'userId', None, None, ), # 1
-    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
+  )
-  def __init__(self, userId=None, isSessionId=None,):
+  def __init__(self, userId=None,):
     self.userId = userId
-    self.isSessionId = isSessionId
   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
       if fid == 1:
         if ftype == TType.I64:
           self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.isSessionId = iprot.readBool();
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('getInternalInfo_args')
+    oprot.writeStructBegin('getUserState_args')
     if self.userId != None:
       oprot.writeFieldBegin('userId', TType.I64, 1)
       oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
-    if self.isSessionId != None:
-      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
-      oprot.writeBool(self.isSessionId)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getInternalInfo_result:
+class getUserState_result:
   """
   Attributes:
    - success
-   - ucx
+   - ucex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserInternalInfo, UserInternalInfo.thrift_spec), None, ), # 0
+    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, ucex=None,):
     self.success = success
-    self.ucx = ucx
+    self.ucex = ucex
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.STRUCT:
-          self.success = UserInternalInfo()
+          self.success = UserState()
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.ucex = UserContextException()
-          self.ucx.read(iprot)
+          self.ucex.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('getInternalInfo_result')
+    oprot.writeStructBegin('getUserState_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.ucex != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.ucex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getContext_args:
+class authenticateUser_args:
   """
   Attributes:
    - email
    - password
   """
   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('getContext_args')
+    oprot.writeStructBegin('authenticateUser_args')
     if self.email != None:
       oprot.writeFieldBegin('email', TType.STRING, 1)
       oprot.writeString(self.email)
       oprot.writeFieldEnd()
     if self.password != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getContext_result:
+class authenticateUser_result:
   """
   Attributes:
    - success
-   - ax
+   - auex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
+    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ax=None,):
+  def __init__(self, success=None, auex=None,):
     self.success = success
-    self.ax = ax
+    self.auex = auex
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.STRUCT:
-          self.success = UserContext()
+          self.success = User()
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ax = AuthenticationException()
+          self.auex = AuthenticationException()
-          self.ax.read(iprot)
+          self.auex.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('getContext_result')
+    oprot.writeStructBegin('authenticateUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
-    if self.ax != None:
+    if self.auex != None:
-      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
+      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
-      self.ax.write(oprot)
+      self.auex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class authenticateUser_args:
+class userExists_args:
   """
   Attributes:
-   - handle
-   - password
-   - isEmail
+   - email
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'handle', None, None, ), # 1
+    (1, TType.STRING, 'email', None, None, ), # 1
-    (2, TType.STRING, 'password', None, None, ), # 2
-    (3, TType.BOOL, 'isEmail', None, None, ), # 3
+  )
-  def __init__(self, handle=None, password=None, isEmail=None,):
+  def __init__(self, email=None,):
-    self.handle = handle
-    self.password = password
-    self.isEmail = isEmail
+    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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.STRING:
-          self.handle = iprot.readString();
+          self.email = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('userExists_args')
+    if self.email != None:
+      oprot.writeFieldBegin('email', TType.STRING, 1)
+      oprot.writeString(self.email)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 userExists_result:
+  """
+  Attributes:
+   - success
+   - ucx
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ucx=None,):
+    self.success = success
+    self.ucx = ucx
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ucx = UserContextException()
+          self.ucx.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('userExists_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.ucx != None:
+      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      self.ucx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 addAddressForUser_args:
+  """
+  Attributes:
+   - userId
+   - address
+   - timestamp
+   - setDefault
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
+    (3, TType.I64, 'timestamp', None, None, ), # 3
+    (4, TType.BOOL, 'setDefault', None, None, ), # 4
+  )
+  def __init__(self, userId=None, address=None, timestamp=None, setDefault=None,):
+    self.userId = userId
+    self.address = address
+    self.timestamp = timestamp
+    self.setDefault = setDefault
+  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.STRING:
+        if ftype == TType.STRUCT:
+          self.address = Address()
-          self.password = iprot.readString();
+          self.address.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 3:
+        if ftype == TType.I64:
+          self.timestamp = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
         if ftype == TType.BOOL:
-          self.isEmail = iprot.readBool();
+          self.setDefault = iprot.readBool();
         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('authenticateUser_args')
+    oprot.writeStructBegin('addAddressForUser_args')
-    if self.handle != None:
+    if self.userId != None:
-      oprot.writeFieldBegin('handle', TType.STRING, 1)
+      oprot.writeFieldBegin('userId', TType.I64, 1)
-      oprot.writeString(self.handle)
+      oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
-    if self.password != None:
+    if self.address != None:
-      oprot.writeFieldBegin('password', TType.STRING, 2)
+      oprot.writeFieldBegin('address', TType.STRUCT, 2)
-      oprot.writeString(self.password)
+      self.address.write(oprot)
       oprot.writeFieldEnd()
-    if self.isEmail != None:
+    if self.timestamp != None:
+      oprot.writeFieldBegin('timestamp', TType.I64, 3)
+      oprot.writeI64(self.timestamp)
+      oprot.writeFieldEnd()
+    if self.setDefault != None:
-      oprot.writeFieldBegin('isEmail', TType.BOOL, 3)
+      oprot.writeFieldBegin('setDefault', TType.BOOL, 4)
-      oprot.writeBool(self.isEmail)
+      oprot.writeBool(self.setDefault)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class authenticateUser_result:
+class addAddressForUser_result:
   """
   Attributes:
    - success
-   - ax
+   - ucx
   """
   thrift_spec = (
     (0, TType.BOOL, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ax=None,):
+  def __init__(self, success=None, ucx=None,):
     self.success = success
-    self.ax = ax
+    self.ucx = ucx
   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
           self.success = iprot.readBool();
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ax = AuthenticationException()
+          self.ucx = UserContextException()
-          self.ax.read(iprot)
+          self.ucx.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('authenticateUser_result')
+    oprot.writeStructBegin('addAddressForUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
-    if self.ax != None:
+    if self.ucx != None:
-      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
+      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
-      self.ax.write(oprot)
+      self.ucx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class userExists_args:
+class removeAddressForUser_args:
   """
   Attributes:
-   - email
+   - userid
+   - addressId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'email', None, None, ), # 1
+    (1, TType.I64, 'userid', None, None, ), # 1
+    (2, TType.I64, 'addressId', None, None, ), # 2
+  )
-  def __init__(self, email=None,):
+  def __init__(self, userid=None, addressId=None,):
-    self.email = email
+    self.userid = userid
+    self.addressId = addressId
   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.userid = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.addressId = 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('userExists_args')
+    oprot.writeStructBegin('removeAddressForUser_args')
-    if self.email != None:
+    if self.userid != None:
-      oprot.writeFieldBegin('email', TType.STRING, 1)
+      oprot.writeFieldBegin('userid', TType.I64, 1)
-      oprot.writeString(self.email)
+      oprot.writeI64(self.userid)
+      oprot.writeFieldEnd()
+    if self.addressId != None:
+      oprot.writeFieldBegin('addressId', TType.I64, 2)
+      oprot.writeI64(self.addressId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class userExists_result:
+class removeAddressForUser_result:
   """
   Attributes:
    - success
    - ucx
   """
   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('userExists_result')
+    oprot.writeStructBegin('removeAddressForUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ucx != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addIpAdressForUser_args:
+class setUserAsLoggedIn_args:
   """
   Attributes:
-   - ip
-   - timestamp
    - userId
+   - timestamp
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'ip', None, None, ), # 1
+    (1, TType.I64, 'userId', None, None, ), # 1
     (2, TType.I64, 'timestamp', None, None, ), # 2
-    (3, TType.I64, 'userId', None, None, ), # 3
+  )
-  def __init__(self, ip=None, timestamp=None, userId=None,):
+  def __init__(self, userId=None, timestamp=None,):
-    self.ip = ip
-    self.timestamp = timestamp
     self.userId = userId
+    self.timestamp = timestamp
   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.ip = iprot.readString();
+          self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
           self.timestamp = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.I64:
-          self.userId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('addIpAdressForUser_args')
+    oprot.writeStructBegin('setUserAsLoggedIn_args')
-    if self.ip != None:
+    if self.userId != None:
-      oprot.writeFieldBegin('ip', TType.STRING, 1)
+      oprot.writeFieldBegin('userId', TType.I64, 1)
-      oprot.writeString(self.ip)
+      oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
     if self.timestamp != None:
       oprot.writeFieldBegin('timestamp', TType.I64, 2)
       oprot.writeI64(self.timestamp)
       oprot.writeFieldEnd()
-    if self.userId != None:
-      oprot.writeFieldBegin('userId', TType.I64, 3)
-      oprot.writeI64(self.userId)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addIpAdressForUser_result:
+class setUserAsLoggedIn_result:
   """
   Attributes:
    - success
    - ucx
   """
   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('addIpAdressForUser_result')
+    oprot.writeStructBegin('setUserAsLoggedIn_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ucx != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addAddressForUser_args:
+class setUserAsLoggedOut_args:
   """
   Attributes:
-   - address
    - userid
    - timestamp
-   - setDefault
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
-    (2, TType.I64, 'userid', None, None, ), # 2
+    (1, TType.I64, 'userid', None, None, ), # 1
-    (3, TType.I64, 'timestamp', None, None, ), # 3
+    (2, TType.I64, 'timestamp', None, None, ), # 2
-    (4, TType.BOOL, 'setDefault', None, None, ), # 4
+  )
-  def __init__(self, address=None, userid=None, timestamp=None, setDefault=None,):
+  def __init__(self, userid=None, timestamp=None,):
-    self.address = address
     self.userid = userid
     self.timestamp = timestamp
-    self.setDefault = setDefault
   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:
-          self.address = Address()
-          self.address.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
         if ftype == TType.I64:
           self.userid = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 3:
+      elif fid == 2:
         if ftype == TType.I64:
           self.timestamp = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.BOOL:
-          self.setDefault = iprot.readBool();
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('addAddressForUser_args')
+    oprot.writeStructBegin('setUserAsLoggedOut_args')
-    if self.address != None:
-      oprot.writeFieldBegin('address', TType.STRUCT, 1)
-      self.address.write(oprot)
-      oprot.writeFieldEnd()
     if self.userid != None:
-      oprot.writeFieldBegin('userid', TType.I64, 2)
+      oprot.writeFieldBegin('userid', TType.I64, 1)
       oprot.writeI64(self.userid)
       oprot.writeFieldEnd()
     if self.timestamp != None:
-      oprot.writeFieldBegin('timestamp', TType.I64, 3)
+      oprot.writeFieldBegin('timestamp', TType.I64, 2)
       oprot.writeI64(self.timestamp)
       oprot.writeFieldEnd()
-    if self.setDefault != None:
-      oprot.writeFieldBegin('setDefault', TType.BOOL, 4)
-      oprot.writeBool(self.setDefault)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addAddressForUser_result:
+class setUserAsLoggedOut_result:
   """
   Attributes:
    - success
    - ucx
   """
   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('addAddressForUser_result')
+    oprot.writeStructBegin('setUserAsLoggedOut_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ucx != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class removeAddressForUser_args:
+class setDefaultAddress_args:
   """
   Attributes:
    - userid
    - addressId
   """
   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('removeAddressForUser_args')
+    oprot.writeStructBegin('setDefaultAddress_args')
     if self.userid != None:
       oprot.writeFieldBegin('userid', TType.I64, 1)
       oprot.writeI64(self.userid)
       oprot.writeFieldEnd()
     if self.addressId != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class removeAddressForUser_result:
+class setDefaultAddress_result:
   """
   Attributes:
    - success
    - ucx
   """
   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('removeAddressForUser_result')
+    oprot.writeStructBegin('setDefaultAddress_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ucx != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setUserAsLoggedIn_args:
+class updatePassword_args:
   """
   Attributes:
-   - userId
+   - userid
-   - timestamp
+   - password
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userId', None, None, ), # 1
+    (1, TType.I64, 'userid', None, None, ), # 1
-    (2, TType.I64, 'timestamp', None, None, ), # 2
+    (2, TType.STRING, 'password', None, None, ), # 2
+  )
-  def __init__(self, userId=None, timestamp=None,):
+  def __init__(self, userid=None, password=None,):
-    self.userId = userId
+    self.userid = userid
-    self.timestamp = timestamp
+    self.password = password
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userId = iprot.readI64();
+          self.userid = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.I64:
+        if ftype == TType.STRING:
-          self.timestamp = iprot.readI64();
+          self.password = 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('setUserAsLoggedIn_args')
+    oprot.writeStructBegin('updatePassword_args')
-    if self.userId != None:
+    if self.userid != None:
-      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeFieldBegin('userid', TType.I64, 1)
-      oprot.writeI64(self.userId)
+      oprot.writeI64(self.userid)
       oprot.writeFieldEnd()
-    if self.timestamp != None:
+    if self.password != None:
-      oprot.writeFieldBegin('timestamp', TType.I64, 2)
+      oprot.writeFieldBegin('password', TType.STRING, 2)
-      oprot.writeI64(self.timestamp)
+      oprot.writeString(self.password)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setUserAsLoggedIn_result:
+class updatePassword_result:
   """
   Attributes:
    - success
    - ucx
   """
   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('setUserAsLoggedIn_result')
+    oprot.writeStructBegin('updatePassword_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ucx != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setUserAsLoggedOut_args:
+class createCart_args:
   """
   Attributes:
-   - userid
+   - userId
-   - timestamp
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'userId', None, None, ), # 1
-    (2, TType.I64, 'timestamp', None, None, ), # 2
+  )
-  def __init__(self, userid=None, timestamp=None,):
+  def __init__(self, userId=None,):
-    self.userid = userid
+    self.userId = userId
-    self.timestamp = timestamp
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createCart_args')
+    if self.userId != None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 createCart_result:
+  """
+  Attributes:
+   - success
+   - scx
+  """
+  thrift_spec = (
+    (0, TType.I64, 'success', None, 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
-      elif fid == 2:
+      if fid == 0:
         if ftype == TType.I64:
-          self.timestamp = iprot.readI64();
+          self.success = iprot.readI64();
+        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()
   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('setUserAsLoggedOut_args')
+    oprot.writeStructBegin('createCart_result')
-    if self.userid != None:
+    if self.success != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('success', TType.I64, 0)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.success)
       oprot.writeFieldEnd()
-    if self.timestamp != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('timestamp', TType.I64, 2)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      oprot.writeI64(self.timestamp)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class getCurrentCart_args:
+  """
+  Attributes:
+   - userId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+  )
+  def __init__(self, userId=None,):
+    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
+    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)
+      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('getCurrentCart_args')
+    if self.userId != None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 setUserAsLoggedOut_result:
+class getCurrentCart_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     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 = Cart()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = ShoppingCartException()
-          self.ucx.read(iprot)
+          self.scx.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('setUserAsLoggedOut_result')
+    oprot.writeStructBegin('getCurrentCart_result')
     if self.success != 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.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setDefaultAddress_args:
+class getCart_args:
   """
   Attributes:
-   - userid
+   - cartId
-   - addressId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'cartId', None, None, ), # 1
-    (2, TType.I64, 'addressId', None, None, ), # 2
+  )
-  def __init__(self, userid=None, addressId=None,):
+  def __init__(self, cartId=None,):
-    self.userid = userid
+    self.cartId = cartId
-    self.addressId = addressId
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.cartId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I64:
-          self.addressId = 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('setDefaultAddress_args')
+    oprot.writeStructBegin('getCart_args')
-    if self.userid != None:
+    if self.cartId != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.cartId)
-      oprot.writeFieldEnd()
-    if self.addressId != None:
-      oprot.writeFieldBegin('addressId', TType.I64, 2)
-      oprot.writeI64(self.addressId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setDefaultAddress_result:
+class getCart_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     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 = Cart()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = ShoppingCartException()
-          self.ucx.read(iprot)
+          self.scx.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('setDefaultAddress_result')
+    oprot.writeStructBegin('getCart_result')
     if self.success != 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.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class updatePassword_args:
+class getCartsForUser_args:
   """
   Attributes:
-   - userid
+   - userId
-   - password
+   - status
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'userId', None, None, ), # 1
-    (2, TType.STRING, 'password', None, None, ), # 2
+    (2, TType.I32, 'status', None, None, ), # 2
+  )
-  def __init__(self, userid=None, password=None,):
+  def __init__(self, userId=None, status=None,):
-    self.userid = userid
+    self.userId = userId
-    self.password = password
+    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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.STRING:
+        if ftype == TType.I32:
-          self.password = iprot.readString();
+          self.status = iprot.readI32();
         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('updatePassword_args')
+    oprot.writeStructBegin('getCartsForUser_args')
-    if self.userid != None:
+    if self.userId != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('userId', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
-    if self.password != None:
+    if self.status != None:
-      oprot.writeFieldBegin('password', TType.STRING, 2)
+      oprot.writeFieldBegin('status', TType.I32, 2)
-      oprot.writeString(self.password)
+      oprot.writeI32(self.status)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class updatePassword_result:
+class getCartsForUser_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype47, _size44) = iprot.readListBegin()
+          for _i48 in xrange(_size44):
+            _elem49 = Cart()
+            _elem49.read(iprot)
-          self.success = iprot.readBool();
+            self.success.append(_elem49)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = ShoppingCartException()
-          self.ucx.read(iprot)
+          self.scx.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('updatePassword_result')
+    oprot.writeStructBegin('getCartsForUser_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      oprot.writeBool(self.success)
+      for iter50 in self.success:
+        iter50.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class deleteUser_args:
+class getCartsByStatus_args:
   """
   Attributes:
-   - userid
+   - status
-   - isSessionId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I32, 'status', None, None, ), # 1
-    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
+  )
+  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 != None:
+      oprot.writeFieldBegin('status', TType.I32, 1)
+      oprot.writeI32(self.status)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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, userid=None, isSessionId=None,):
+  def __init__(self, success=None, scx=None,):
+    self.success = success
-    self.userid = userid
+    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 = []
+          (_etype54, _size51) = iprot.readListBegin()
+          for _i55 in xrange(_size51):
+            _elem56 = Cart()
+            _elem56.read(iprot)
+            self.success.append(_elem56)
+          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 != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter57 in self.success:
+        iter57.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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
+   - status
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'from_time', None, None, ), # 1
+    (2, TType.I64, 'to_time', None, None, ), # 2
+    (3, TType.I32, 'status', None, None, ), # 3
+  )
+  def __init__(self, from_time=None, to_time=None, status=None,):
-    self.isSessionId = isSessionId
+    self.from_time = from_time
+    self.to_time = to_time
+    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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.from_time = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.BOOL:
+        if ftype == TType.I64:
-          self.isSessionId = iprot.readBool();
+          self.to_time = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I32:
+          self.status = iprot.readI32();
         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('getCartsByTime_args')
-    if self.userid != None:
+    if self.from_time != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('from_time', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.from_time)
       oprot.writeFieldEnd()
-    if self.isSessionId != None:
+    if self.to_time != None:
-      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
+      oprot.writeFieldBegin('to_time', TType.I64, 2)
-      oprot.writeBool(self.isSessionId)
+      oprot.writeI64(self.to_time)
+      oprot.writeFieldEnd()
+    if self.status != None:
+      oprot.writeFieldBegin('status', TType.I32, 3)
+      oprot.writeI32(self.status)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class deleteUser_result:
+class getCartsByTime_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype61, _size58) = iprot.readListBegin()
+          for _i62 in xrange(_size58):
+            _elem63 = Cart()
+            _elem63.read(iprot)
-          self.success = iprot.readBool();
+            self.success.append(_elem63)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = ShoppingCartException()
-          self.ucx.read(iprot)
+          self.scx.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_result')
+    oprot.writeStructBegin('getCartsByTime_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      oprot.writeBool(self.success)
+      for iter64 in self.success:
+        iter64.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class sendEmailVerification_args:
+class changeCartStatus_args:
   """
   Attributes:
-   - userid
+   - cartId
+   - status
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'cartId', None, None, ), # 1
+    (2, TType.I32, 'status', None, None, ), # 2
+  )
-  def __init__(self, userid=None,):
+  def __init__(self, cartId=None, status=None,):
-    self.userid = userid
+    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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          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()
   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('sendEmailVerification_args')
+    oprot.writeStructBegin('changeCartStatus_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
+    if self.status != None:
+      oprot.writeFieldBegin('status', TType.I32, 2)
+      oprot.writeI32(self.status)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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
+   - quantity
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'cartId', None, None, ), # 1
+    (2, TType.I64, 'itemId', None, None, ), # 2
+    (3, TType.I64, 'quantity', None, None, ), # 3
+  )
+  def __init__(self, cartId=None, itemId=None, quantity=None,):
+    self.cartId = cartId
+    self.itemId = itemId
+    self.quantity = quantity
+  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.I64:
+          self.itemId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.quantity = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('addItemToCart_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
-    if self.userid != None:
+    if self.itemId != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('itemId', TType.I64, 2)
+      oprot.writeI64(self.itemId)
+      oprot.writeFieldEnd()
+    if self.quantity != None:
+      oprot.writeFieldBegin('quantity', TType.I64, 3)
+      oprot.writeI64(self.quantity)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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_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('addItemToCart_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 deleteItemFromCart_args:
+  """
+  Attributes:
+   - cartId
+   - itemId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'cartId', None, None, ), # 1
+    (2, TType.I64, 'itemId', None, None, ), # 2
+  )
+  def __init__(self, cartId=None, itemId=None,):
+    self.cartId = cartId
+    self.itemId = itemId
+  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.I64:
+          self.itemId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('deleteItemFromCart_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
+    if self.itemId != None:
+      oprot.writeFieldBegin('itemId', TType.I64, 2)
+      oprot.writeI64(self.itemId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 deleteItemFromCart_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('deleteItemFromCart_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 changeQuantity_args:
+  """
+  Attributes:
+   - cartId
+   - itemId
+   - quantity
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'cartId', None, None, ), # 1
+    (2, TType.I64, 'itemId', None, None, ), # 2
+    (3, TType.I64, 'quantity', None, None, ), # 3
+  )
+  def __init__(self, cartId=None, itemId=None, quantity=None,):
+    self.cartId = cartId
+    self.itemId = itemId
+    self.quantity = quantity
+  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.I64:
+          self.itemId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.quantity = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('changeQuantity_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
+    if self.itemId != None:
+      oprot.writeFieldBegin('itemId', TType.I64, 2)
+      oprot.writeI64(self.itemId)
+      oprot.writeFieldEnd()
+    if self.quantity != None:
+      oprot.writeFieldBegin('quantity', TType.I64, 3)
+      oprot.writeI64(self.quantity)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 changeQuantity_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('changeQuantity_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 changeItemStatus_args:
+  """
+  Attributes:
+   - cartId
+   - itemId
+   - status
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'cartId', None, None, ), # 1
+    (2, TType.I64, 'itemId', None, None, ), # 2
+    (3, TType.I32, 'status', None, None, ), # 3
+  )
+  def __init__(self, cartId=None, itemId=None, status=None,):
+    self.cartId = cartId
+    self.itemId = itemId
+    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.I64:
+          self.itemId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        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('changeItemStatus_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
+    if self.itemId != None:
+      oprot.writeFieldBegin('itemId', TType.I64, 2)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.itemId)
+      oprot.writeFieldEnd()
+    if self.status != None:
+      oprot.writeFieldBegin('status', TType.I32, 3)
+      oprot.writeI32(self.status)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 changeItemStatus_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('changeItemStatus_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class addAddressToCart_args:
+  """
+  Attributes:
+   - cartId
+   - addressId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'cartId', None, None, ), # 1
+    (2, TType.I64, 'addressId', None, None, ), # 2
+  )
+  def __init__(self, cartId=None, addressId=None,):
+    self.cartId = cartId
+    self.addressId = addressId
+  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.I64:
+          self.addressId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('addAddressToCart_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
+    if self.addressId != None:
+      oprot.writeFieldBegin('addressId', TType.I64, 2)
+      oprot.writeI64(self.addressId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 sendEmailVerification_result:
+class addAddressToCart_result:
+  thrift_spec = (
+  )
+  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
+      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('addAddressToCart_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 commitCart_args:
+  """
+  Attributes:
+   - cartId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'cartId', None, None, ), # 1
+  )
+  def __init__(self, cartId=None,):
+    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
+    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)
+      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('commitCart_args')
+    if self.cartId != None:
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
+      oprot.writeI64(self.cartId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 commitCart_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
     (0, TType.BOOL, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
           self.success = iprot.readBool();
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = ShoppingCartException()
-          self.ucx.read(iprot)
+          self.scx.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('sendEmailVerification_result')
+    oprot.writeStructBegin('commitCart_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class sendSMSVerification_args:
+class validateCart_args:
   """
   Attributes:
-   - userid
+   - cartId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'cartId', None, None, ), # 1
+  )
-  def __init__(self, userid=None,):
+  def __init__(self, cartId=None,):
-    self.userid = userid
+    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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          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('sendSMSVerification_args')
+    oprot.writeStructBegin('validateCart_args')
-    if self.userid != None:
+    if self.cartId != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('cartId', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.cartId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class sendSMSVerification_result:
+class validateCart_result:
   """
   Attributes:
    - success
-   - ucx
   """
   thrift_spec = (
     (0, TType.BOOL, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None,):
     self.success = success
-    self.ucx = ucx
   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
       if fid == 0:
         if ftype == TType.BOOL:
           self.success = iprot.readBool();
         else:
           iprot.skip(ftype)
-      elif fid == 1:
-        if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
-          self.ucx.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('sendSMSVerification_result')
+    oprot.writeStructBegin('validateCart_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 mergeCart_args:
+  """
+  Attributes:
+   - fromCartId
+   - toCartId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'fromCartId', None, None, ), # 1
+    (2, TType.I64, 'toCartId', None, None, ), # 2
+  )
+  def __init__(self, fromCartId=None, toCartId=None,):
+    self.fromCartId = fromCartId
+    self.toCartId = toCartId
+  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.fromCartId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.toCartId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('mergeCart_args')
-    if self.ucx != None:
+    if self.fromCartId != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
+      oprot.writeI64(self.fromCartId)
-      self.ucx.write(oprot)
+      oprot.writeFieldEnd()
+    if self.toCartId != None:
+      oprot.writeFieldBegin('toCartId', TType.I64, 2)
+      oprot.writeI64(self.toCartId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class mergeCart_result:
+  thrift_spec = (
+  )
+  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
+      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('mergeCart_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 confirmEmailVerification_args:
+class addWidget_args:
   """
   Attributes:
-   - userid
+   - widget
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.STRUCT, 'widget', (Widget, Widget.thrift_spec), None, ), # 1
+  )
+  def __init__(self, widget=None,):
+    self.widget = widget
+  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.widget = Widget()
+          self.widget.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('addWidget_args')
+    if self.widget != None:
+      oprot.writeFieldBegin('widget', TType.STRUCT, 1)
+      self.widget.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 addWidget_result:
+  """
+  Attributes:
+   - scx
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, userid=None,):
+  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 = WidgetException()
+          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('addWidget_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 addItemToWidget_args:
+  """
+  Attributes:
+   - widget_id
+   - items
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'widget_id', None, None, ), # 1
+    (2, TType.LIST, 'items', (TType.I64,None), None, ), # 2
+  )
+  def __init__(self, widget_id=None, items=None,):
+    self.widget_id = widget_id
-    self.userid = userid
+    self.items = items
   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
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.widget_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.items = []
+          (_etype68, _size65) = iprot.readListBegin()
+          for _i69 in xrange(_size65):
+            _elem70 = iprot.readI64();
+            self.items.append(_elem70)
+          iprot.readListEnd()
         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('confirmEmailVerification_args')
+    oprot.writeStructBegin('addItemToWidget_args')
-    if self.userid != None:
+    if self.widget_id != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('widget_id', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.widget_id)
+      oprot.writeFieldEnd()
+    if self.items != None:
+      oprot.writeFieldBegin('items', TType.LIST, 2)
+      oprot.writeListBegin(TType.I64, len(self.items))
+      for iter71 in self.items:
+        oprot.writeI64(iter71)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class confirmEmailVerification_result:
+class addItemToWidget_result:
+  """
+  Attributes:
+   - scx
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.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 = WidgetException()
+          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('addItemToWidget_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 deleteItemFromWidget_args:
+  """
+  Attributes:
+   - widget_id
+   - item_id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'widget_id', None, None, ), # 1
+    (2, TType.I64, 'item_id', None, None, ), # 2
+  )
+  def __init__(self, widget_id=None, item_id=None,):
+    self.widget_id = widget_id
+    self.item_id = item_id
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.widget_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.item_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('deleteItemFromWidget_args')
+    if self.widget_id != None:
+      oprot.writeFieldBegin('widget_id', TType.I64, 1)
+      oprot.writeI64(self.widget_id)
+      oprot.writeFieldEnd()
+    if self.item_id != None:
+      oprot.writeFieldBegin('item_id', TType.I64, 2)
+      oprot.writeI64(self.item_id)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 deleteItemFromWidget_result:
+  """
+  Attributes:
+   - scx
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.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 = WidgetException()
+          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('deleteItemFromWidget_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 updateWidget_args:
+  """
+  Attributes:
+   - widgetId
+   - enable
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'widgetId', None, None, ), # 1
+    (2, TType.BOOL, 'enable', None, None, ), # 2
+  )
+  def __init__(self, widgetId=None, enable=None,):
+    self.widgetId = widgetId
+    self.enable = enable
+  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.widgetId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.BOOL:
+          self.enable = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateWidget_args')
+    if self.widgetId != None:
+      oprot.writeFieldBegin('widgetId', TType.I64, 1)
+      oprot.writeI64(self.widgetId)
+      oprot.writeFieldEnd()
+    if self.enable != None:
+      oprot.writeFieldBegin('enable', TType.BOOL, 2)
+      oprot.writeBool(self.enable)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 updateWidget_result:
+  """
+  Attributes:
+   - scx
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.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 = WidgetException()
+          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('updateWidget_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 updateWidgetItem_args:
+  """
+  Attributes:
+   - widgetId
+   - enable
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'widgetId', None, None, ), # 1
+    (2, TType.BOOL, 'enable', None, None, ), # 2
+  )
+  def __init__(self, widgetId=None, enable=None,):
+    self.widgetId = widgetId
+    self.enable = enable
+  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.widgetId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.BOOL:
+          self.enable = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateWidgetItem_args')
+    if self.widgetId != None:
+      oprot.writeFieldBegin('widgetId', TType.I64, 1)
+      oprot.writeI64(self.widgetId)
+      oprot.writeFieldEnd()
+    if self.enable != None:
+      oprot.writeFieldBegin('enable', TType.BOOL, 2)
+      oprot.writeBool(self.enable)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 updateWidgetItem_result:
+  """
+  Attributes:
+   - scx
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.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 = WidgetException()
+          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('updateWidgetItem_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getWidget_args:
+  """
+  Attributes:
+   - type
+   - userId
+   - onlyEnabled
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I32, 'type', None, None, ), # 1
+    (2, TType.I64, 'userId', None, None, ), # 2
+    (3, TType.BOOL, 'onlyEnabled', None, None, ), # 3
+  )
+  def __init__(self, type=None, userId=None, onlyEnabled=None,):
+    self.type = type
+    self.userId = userId
+    self.onlyEnabled = onlyEnabled
+  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.type = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.BOOL:
+          self.onlyEnabled = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getWidget_args')
+    if self.type != None:
+      oprot.writeFieldBegin('type', TType.I32, 1)
+      oprot.writeI32(self.type)
+      oprot.writeFieldEnd()
+    if self.userId != None:
+      oprot.writeFieldBegin('userId', TType.I64, 2)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.onlyEnabled != None:
+      oprot.writeFieldBegin('onlyEnabled', TType.BOOL, 3)
+      oprot.writeBool(self.onlyEnabled)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getWidget_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     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 = Widget()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = WidgetException()
-          self.ucx.read(iprot)
+          self.scx.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('confirmEmailVerification_result')
+    oprot.writeStructBegin('getWidget_result')
     if self.success != 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.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class confirmSMSVerification_args:
+class getMyResearch_args:
   """
   Attributes:
-   - userid
+   - user_id
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'user_id', None, None, ), # 1
+  )
-  def __init__(self, userid=None,):
+  def __init__(self, user_id=None,):
-    self.userid = userid
+    self.user_id = user_id
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.user_id = 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('confirmSMSVerification_args')
+    oprot.writeStructBegin('getMyResearch_args')
-    if self.userid != None:
+    if self.user_id != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('user_id', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.user_id)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class confirmSMSVerification_result:
+class getMyResearch_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     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 = Widget()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = WidgetException()
-          self.ucx.read(iprot)
+          self.scx.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('confirmSMSVerification_result')
+    oprot.writeStructBegin('getMyResearch_result')
     if self.success != 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.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addSocialhandle_args:
+class updateMyResearch_args:
   """
   Attributes:
-   - userid
+   - user_id
-   - socialService
-   - handle
+   - item_id
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'user_id', None, None, ), # 1
-    (2, TType.STRING, 'socialService', None, None, ), # 2
-    (3, TType.STRING, 'handle', None, None, ), # 3
+    (2, TType.I64, 'item_id', None, None, ), # 2
+  )
-  def __init__(self, userid=None, socialService=None, handle=None,):
+  def __init__(self, user_id=None, item_id=None,):
-    self.userid = userid
+    self.user_id = user_id
-    self.socialService = socialService
-    self.handle = handle
+    self.item_id = item_id
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.user_id = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.STRING:
+        if ftype == TType.I64:
-          self.socialService = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRING:
-          self.handle = iprot.readString();
+          self.item_id = 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('addSocialhandle_args')
+    oprot.writeStructBegin('updateMyResearch_args')
-    if self.userid != None:
+    if self.user_id != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('user_id', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.user_id)
       oprot.writeFieldEnd()
-    if self.socialService != None:
-      oprot.writeFieldBegin('socialService', TType.STRING, 2)
-      oprot.writeString(self.socialService)
-      oprot.writeFieldEnd()
-    if self.handle != None:
+    if self.item_id != None:
-      oprot.writeFieldBegin('handle', TType.STRING, 3)
+      oprot.writeFieldBegin('item_id', TType.I64, 2)
-      oprot.writeString(self.handle)
+      oprot.writeI64(self.item_id)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addSocialhandle_result:
+class updateMyResearch_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
     (0, TType.BOOL, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
           self.success = iprot.readBool();
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = WidgetException()
-          self.ucx.read(iprot)
+          self.scx.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('addSocialhandle_result')
+    oprot.writeStructBegin('updateMyResearch_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
-    if self.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class sendNewPasswordById_args:
+class deleteItemFromMyResearch_args:
   """
   Attributes:
-   - userid
+   - user_id
+   - item_id
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'userid', None, None, ), # 1
+    (1, TType.I64, 'user_id', None, None, ), # 1
+    (2, TType.I64, 'item_id', None, None, ), # 2
+  )
-  def __init__(self, userid=None,):
+  def __init__(self, user_id=None, item_id=None,):
-    self.userid = userid
+    self.user_id = user_id
+    self.item_id = item_id
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.userid = iprot.readI64();
+          self.user_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.item_id = 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('sendNewPasswordById_args')
+    oprot.writeStructBegin('deleteItemFromMyResearch_args')
-    if self.userid != None:
+    if self.user_id != None:
-      oprot.writeFieldBegin('userid', TType.I64, 1)
+      oprot.writeFieldBegin('user_id', TType.I64, 1)
-      oprot.writeI64(self.userid)
+      oprot.writeI64(self.user_id)
+      oprot.writeFieldEnd()
+    if self.item_id != None:
+      oprot.writeFieldBegin('item_id', TType.I64, 2)
+      oprot.writeI64(self.item_id)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class deleteItemFromMyResearch_result:
+  """
+  Attributes:
+   - scx
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.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 = WidgetException()
+          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('deleteItemFromMyResearch_result')
+    if self.scx != None:
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
+      self.scx.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 updateRatings_args:
+  """
+  Attributes:
+   - item_id
+   - type
+   - rating
+   - user_id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'item_id', None, None, ), # 1
+    (2, TType.I32, 'type', None, None, ), # 2
+    (3, TType.DOUBLE, 'rating', None, None, ), # 3
+    (4, TType.I64, 'user_id', None, None, ), # 4
+  )
+  def __init__(self, item_id=None, type=None, rating=None, user_id=None,):
+    self.item_id = item_id
+    self.type = type
+    self.rating = rating
+    self.user_id = user_id
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.item_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I32:
+          self.type = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.DOUBLE:
+          self.rating = iprot.readDouble();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.I64:
+          self.user_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateRatings_args')
+    if self.item_id != None:
+      oprot.writeFieldBegin('item_id', TType.I64, 1)
+      oprot.writeI64(self.item_id)
+      oprot.writeFieldEnd()
+    if self.type != None:
+      oprot.writeFieldBegin('type', TType.I32, 2)
+      oprot.writeI32(self.type)
+      oprot.writeFieldEnd()
+    if self.rating != None:
+      oprot.writeFieldBegin('rating', TType.DOUBLE, 3)
+      oprot.writeDouble(self.rating)
+      oprot.writeFieldEnd()
+    if self.user_id != None:
+      oprot.writeFieldBegin('user_id', TType.I64, 4)
+      oprot.writeI64(self.user_id)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 sendNewPasswordById_result:
+class updateRatings_result:
+  thrift_spec = (
+  )
+  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
+      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('updateRatings_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getRatings_args:
+  """
+  Attributes:
+   - item_id
+   - user_id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'item_id', None, None, ), # 1
+    (2, TType.I64, 'user_id', None, None, ), # 2
+  )
+  def __init__(self, item_id=None, user_id=None,):
+    self.item_id = item_id
+    self.user_id = user_id
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.item_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.user_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getRatings_args')
+    if self.item_id != None:
+      oprot.writeFieldBegin('item_id', TType.I64, 1)
+      oprot.writeI64(self.item_id)
+      oprot.writeFieldEnd()
+    if self.user_id != None:
+      oprot.writeFieldBegin('user_id', TType.I64, 2)
+      oprot.writeI64(self.user_id)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getRatings_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (RatingsWidget, RatingsWidget.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     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 = RatingsWidget()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = WidgetException()
-          self.ucx.read(iprot)
+          self.scx.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('sendNewPasswordById_result')
+    oprot.writeStructBegin('getRatings_result')
     if self.success != 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.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class sendNewPasswordByHandle_args:
+class updateBrowseHistory_args:
   """
   Attributes:
-   - emailOrHandle
+   - user_id
-   - isEmail
+   - item_id
+   - isSessionId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'emailOrHandle', None, None, ), # 1
+    (1, TType.I64, 'user_id', None, None, ), # 1
-    (2, TType.BOOL, 'isEmail', None, None, ), # 2
+    (2, TType.I64, 'item_id', None, None, ), # 2
+    (3, TType.BOOL, 'isSessionId', None, None, ), # 3
+  )
-  def __init__(self, emailOrHandle=None, isEmail=None,):
+  def __init__(self, user_id=None, item_id=None, isSessionId=None,):
-    self.emailOrHandle = emailOrHandle
+    self.user_id = user_id
-    self.isEmail = isEmail
+    self.item_id = item_id
+    self.isSessionId = isSessionId
   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.user_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
-          self.emailOrHandle = iprot.readString();
+          self.item_id = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.BOOL:
+          self.isSessionId = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateBrowseHistory_args')
+    if self.user_id != None:
+      oprot.writeFieldBegin('user_id', TType.I64, 1)
+      oprot.writeI64(self.user_id)
+      oprot.writeFieldEnd()
+    if self.item_id != None:
+      oprot.writeFieldBegin('item_id', TType.I64, 2)
+      oprot.writeI64(self.item_id)
+      oprot.writeFieldEnd()
+    if self.isSessionId != None:
+      oprot.writeFieldBegin('isSessionId', TType.BOOL, 3)
+      oprot.writeBool(self.isSessionId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 updateBrowseHistory_result:
+  thrift_spec = (
+  )
+  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
+      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('updateBrowseHistory_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getBrowseHistory_args:
+  """
+  Attributes:
+   - userId
+   - isSessionId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
+  )
+  def __init__(self, userId=None, isSessionId=None,):
+    self.userId = userId
+    self.isSessionId = isSessionId
+  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.BOOL:
-          self.isEmail = iprot.readBool();
+          self.isSessionId = iprot.readBool();
         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('sendNewPasswordByHandle_args')
+    oprot.writeStructBegin('getBrowseHistory_args')
-    if self.emailOrHandle != None:
+    if self.userId != None:
-      oprot.writeFieldBegin('emailOrHandle', TType.STRING, 1)
+      oprot.writeFieldBegin('userId', TType.I64, 1)
-      oprot.writeString(self.emailOrHandle)
+      oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
-    if self.isEmail != None:
+    if self.isSessionId != None:
-      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
+      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
-      oprot.writeBool(self.isEmail)
+      oprot.writeBool(self.isSessionId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class sendNewPasswordByHandle_result:
+class getBrowseHistory_result:
   """
   Attributes:
    - success
-   - ucx
+   - scx
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ucx=None,):
+  def __init__(self, success=None, scx=None,):
     self.success = success
-    self.ucx = ucx
+    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
     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 = Widget()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.ucx = UserContextException()
+          self.scx = WidgetException()
-          self.ucx.read(iprot)
+          self.scx.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('sendNewPasswordByHandle_result')
+    oprot.writeStructBegin('getBrowseHistory_result')
     if self.success != 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.ucx != None:
+    if self.scx != None:
-      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
+      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
-      self.ucx.write(oprot)
+      self.scx.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):

Subversion Repositories SmartDukaan

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