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

     Parameters:
      - name
     """
     pass
-  def getAffiliatesByMasterAffiliate(self, id):
+  def getTrackerById(self, id):
     """
     Parameters:
      - id
     """
     pass
-  def createTracker(self, affiliateId, addedOn):
+  def getAffiliatesByMasterAffiliate(self, id):
-    """
-    Parameters:
-     - affiliateId
-     - addedOn
-    """
-    pass
-  def getTrackerById(self, trackerId):
     """
     Parameters:
-     - trackerId
+     - id
     """
     pass
-  def getTrackersByAffiliate(self, affiliateId):
+  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
     """
     Parameters:
      - affiliateId
-    """
-    pass
-  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
-    """
-    Parameters:
-     - trackerId
      - userId
      - event
      - url
      - data
      - addedOn
     Parameters:
      - id
     """
     pass
-  def getTrackLogsByTracker(self, trackerId):
+  def getTrackLogsByAffiliate(self, affiliateId):
     """
     Parameters:
-     - trackerId
+     - affiliateId
     """
     pass
   def getTrackLogsByUser(self, userId):
     """
     Parameters:
      - userId
     """
     pass
-  def getTrackLogs(self, trackerId, userId, event, url):
+  def getTrackLogs(self, userId, event, url):
     """
     Parameters:
-     - trackerId
      - userId
      - event
      - url
     """
     pass
       return result.success
     if result.utx != None:
       raise result.utx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
-  def getAffiliatesByMasterAffiliate(self, id):
+  def getTrackerById(self, id):
     """
     Parameters:
      - id
     """
-    self.send_getAffiliatesByMasterAffiliate(id)
-    return self.recv_getAffiliatesByMasterAffiliate()
-  def send_getAffiliatesByMasterAffiliate(self, id):
-    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
-    args = getAffiliatesByMasterAffiliate_args()
-    args.id = id
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_getAffiliatesByMasterAffiliate(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getAffiliatesByMasterAffiliate_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.utx != None:
-      raise result.utx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
-  def createTracker(self, affiliateId, addedOn):
-    """
-    Parameters:
-     - affiliateId
-     - addedOn
-    """
-    self.send_createTracker(affiliateId, addedOn)
-    return self.recv_createTracker()
-  def send_createTracker(self, affiliateId, addedOn):
-    self._oprot.writeMessageBegin('createTracker', TMessageType.CALL, self._seqid)
-    args = createTracker_args()
-    args.affiliateId = affiliateId
-    args.addedOn = addedOn
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_createTracker(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = createTracker_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.utx != None:
-      raise result.utx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTracker failed: unknown result");
-  def getTrackerById(self, trackerId):
-    """
-    Parameters:
-     - trackerId
-    """
-    self.send_getTrackerById(trackerId)
+    self.send_getTrackerById(id)
     return self.recv_getTrackerById()
-  def send_getTrackerById(self, trackerId):
+  def send_getTrackerById(self, id):
     self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
     args = getTrackerById_args()
-    args.trackerId = trackerId
+    args.id = id
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_getTrackerById(self, ):
       return result.success
     if result.utx != None:
       raise result.utx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
-  def getTrackersByAffiliate(self, affiliateId):
+  def getAffiliatesByMasterAffiliate(self, id):
     """
     Parameters:
-     - affiliateId
+     - id
     """
-    self.send_getTrackersByAffiliate(affiliateId)
+    self.send_getAffiliatesByMasterAffiliate(id)
-    return self.recv_getTrackersByAffiliate()
+    return self.recv_getAffiliatesByMasterAffiliate()
-  def send_getTrackersByAffiliate(self, affiliateId):
+  def send_getAffiliatesByMasterAffiliate(self, id):
-    self._oprot.writeMessageBegin('getTrackersByAffiliate', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
-    args = getTrackersByAffiliate_args()
+    args = getAffiliatesByMasterAffiliate_args()
-    args.affiliateId = affiliateId
+    args.id = id
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getTrackersByAffiliate(self, ):
+  def recv_getAffiliatesByMasterAffiliate(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getTrackersByAffiliate_result()
+    result = getAffiliatesByMasterAffiliate_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
     if result.utx != None:
       raise result.utx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackersByAffiliate failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
-  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
+  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
     """
     Parameters:
-     - trackerId
+     - affiliateId
      - userId
      - event
      - url
      - data
      - addedOn
     """
-    self.send_addTrackLog(trackerId, userId, event, url, data, addedOn)
+    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
     return self.recv_addTrackLog()
-  def send_addTrackLog(self, trackerId, userId, event, url, data, addedOn):
+  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
     self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
     args = addTrackLog_args()
-    args.trackerId = trackerId
+    args.affiliateId = affiliateId
     args.userId = userId
     args.event = event
     args.url = url
     args.data = data
     args.addedOn = addedOn
       return result.success
     if result.utx != None:
       raise result.utx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
-  def getTrackLogsByTracker(self, trackerId):
+  def getTrackLogsByAffiliate(self, affiliateId):
     """
     Parameters:
-     - trackerId
+     - affiliateId
     """
-    self.send_getTrackLogsByTracker(trackerId)
+    self.send_getTrackLogsByAffiliate(affiliateId)
-    return self.recv_getTrackLogsByTracker()
+    return self.recv_getTrackLogsByAffiliate()
-  def send_getTrackLogsByTracker(self, trackerId):
+  def send_getTrackLogsByAffiliate(self, affiliateId):
-    self._oprot.writeMessageBegin('getTrackLogsByTracker', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
-    args = getTrackLogsByTracker_args()
+    args = getTrackLogsByAffiliate_args()
-    args.trackerId = trackerId
+    args.affiliateId = affiliateId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getTrackLogsByTracker(self, ):
+  def recv_getTrackLogsByAffiliate(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getTrackLogsByTracker_result()
+    result = getTrackLogsByAffiliate_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
     if result.utx != None:
       raise result.utx
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByTracker failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
   def getTrackLogsByUser(self, userId):
     """
     Parameters:
      - userId
       return result.success
     if result.utx != None:
       raise result.utx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
-  def getTrackLogs(self, trackerId, userId, event, url):
+  def getTrackLogs(self, userId, event, url):
     """
     Parameters:
-     - trackerId
      - userId
      - event
      - url
     """
-    self.send_getTrackLogs(trackerId, userId, event, url)
+    self.send_getTrackLogs(userId, event, url)
     return self.recv_getTrackLogs()
-  def send_getTrackLogs(self, trackerId, userId, event, url):
+  def send_getTrackLogs(self, userId, event, url):
     self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
     args = getTrackLogs_args()
-    args.trackerId = trackerId
     args.userId = userId
     args.event = event
     args.url = url
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
     self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
     self._processMap["createAffiliate"] = Processor.process_createAffiliate
     self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
     self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
-    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
-    self._processMap["createTracker"] = Processor.process_createTracker
     self._processMap["getTrackerById"] = Processor.process_getTrackerById
-    self._processMap["getTrackersByAffiliate"] = Processor.process_getTrackersByAffiliate
+    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
     self._processMap["addTrackLog"] = Processor.process_addTrackLog
     self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
-    self._processMap["getTrackLogsByTracker"] = Processor.process_getTrackLogsByTracker
+    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
     self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
     self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
     self._processMap["createCart"] = Processor.process_createCart
     self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
     self._processMap["getCart"] = Processor.process_getCart
     args.read(iprot)
     iprot.readMessageEnd()
     result = createMasterAffiliate_result()
     try:
       result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getAllMasterAffiliates_result()
     try:
       result.success = self._handler.getAllMasterAffiliates()
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getMasterAffiliateById_result()
     try:
       result.success = self._handler.getMasterAffiliateById(args.id)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getMasterAffiliateByName_result()
     try:
       result.success = self._handler.getMasterAffiliateByName(args.name)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = createAffiliate_result()
     try:
       result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getAffiliateById_result()
     try:
       result.success = self._handler.getAffiliateById(args.id)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getAffiliateByName_result()
     try:
       result.success = self._handler.getAffiliateByName(args.name)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
-    args = getAffiliatesByMasterAffiliate_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getAffiliatesByMasterAffiliate_result()
-    try:
-      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
-    except UserTrackerException, utx:
-      result.utx = utx
-    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-  def process_createTracker(self, seqid, iprot, oprot):
-    args = createTracker_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = createTracker_result()
-    try:
-      result.success = self._handler.createTracker(args.affiliateId, args.addedOn)
-    except UserTrackerException, utx:
-      result.utx = utx
-    oprot.writeMessageBegin("createTracker", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_getTrackerById(self, seqid, iprot, oprot):
     args = getTrackerById_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getTrackerById_result()
     try:
-      result.success = self._handler.getTrackerById(args.trackerId)
+      result.success = self._handler.getTrackerById(args.id)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getTrackersByAffiliate(self, seqid, iprot, oprot):
+  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
-    args = getTrackersByAffiliate_args()
+    args = getAffiliatesByMasterAffiliate_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getTrackersByAffiliate_result()
+    result = getAffiliatesByMasterAffiliate_result()
     try:
-      result.success = self._handler.getTrackersByAffiliate(args.affiliateId)
+      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
-    oprot.writeMessageBegin("getTrackersByAffiliate", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
   def process_addTrackLog(self, seqid, iprot, oprot):
     args = addTrackLog_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = addTrackLog_result()
     try:
-      result.success = self._handler.addTrackLog(args.trackerId, args.userId, args.event, args.url, args.data, args.addedOn)
+      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getTrackLogById_result()
     try:
       result.success = self._handler.getTrackLogById(args.id)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getTrackLogsByTracker(self, seqid, iprot, oprot):
+  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
-    args = getTrackLogsByTracker_args()
+    args = getTrackLogsByAffiliate_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getTrackLogsByTracker_result()
+    result = getTrackLogsByAffiliate_result()
     try:
-      result.success = self._handler.getTrackLogsByTracker(args.trackerId)
+      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
-    oprot.writeMessageBegin("getTrackLogsByTracker", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
   def process_getTrackLogsByUser(self, seqid, iprot, oprot):
     args.read(iprot)
     iprot.readMessageEnd()
     result = getTrackLogsByUser_result()
     try:
       result.success = self._handler.getTrackLogsByUser(args.userId)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args = getTrackLogs_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getTrackLogs_result()
     try:
-      result.success = self._handler.getTrackLogs(args.trackerId, args.userId, args.event, args.url)
+      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
-    except UserTrackerException, utx:
+    except UserAffiliateException, utx:
       result.utx = utx
     oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getAffiliatesByMasterAffiliate_args:
+class getTrackerById_args:
   """
   Attributes:
    - id
   """
   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('getAffiliatesByMasterAffiliate_args')
+    oprot.writeStructBegin('getTrackerById_args')
     if self.id != None:
       oprot.writeFieldBegin('id', TType.I64, 1)
       oprot.writeI64(self.id)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getAffiliatesByMasterAffiliate_result:
-  """
-  Attributes:
-   - success
-   - utx
-  """
-  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
-  )
-  def __init__(self, success=None, utx=None,):
-    self.success = success
-    self.utx = utx
-  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 = []
-          (_etype66, _size63) = iprot.readListBegin()
-          for _i67 in xrange(_size63):
-            _elem68 = Affiliate()
-            _elem68.read(iprot)
-            self.success.append(_elem68)
-          iprot.readListEnd()
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
-        if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
-          self.utx.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('getAffiliatesByMasterAffiliate_result')
-    if self.success != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter69 in self.success:
-        iter69.write(oprot)
-      oprot.writeListEnd()
-      oprot.writeFieldEnd()
-    if self.utx != None:
-      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
-      self.utx.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 createTracker_args:
-  """
-  Attributes:
-   - affiliateId
-   - addedOn
-  """
-  thrift_spec = (
-    None, # 0
-    (1, TType.I64, 'affiliateId', None, None, ), # 1
-    (2, TType.I64, 'addedOn', None, None, ), # 2
-  )
-  def __init__(self, affiliateId=None, addedOn=None,):
-    self.affiliateId = affiliateId
-    self.addedOn = addedOn
-  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.affiliateId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I64:
-          self.addedOn = 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('createTracker_args')
-    if self.affiliateId != None:
-      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
-      oprot.writeI64(self.affiliateId)
-      oprot.writeFieldEnd()
-    if self.addedOn != None:
-      oprot.writeFieldBegin('addedOn', TType.I64, 2)
-      oprot.writeI64(self.addedOn)
-      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 createTracker_result:
-  """
-  Attributes:
-   - success
-   - utx
-  """
-  thrift_spec = (
-    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
-  )
-  def __init__(self, success=None, utx=None,):
-    self.success = success
-    self.utx = utx
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 0:
-        if ftype == TType.STRUCT:
-          self.success = Tracker()
-          self.success.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
-        if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
-          self.utx.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('createTracker_result')
-    if self.success != None:
-      oprot.writeFieldBegin('success', TType.STRUCT, 0)
-      self.success.write(oprot)
-      oprot.writeFieldEnd()
-    if self.utx != None:
-      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
-      self.utx.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 getTrackerById_args:
-  """
-  Attributes:
-   - trackerId
-  """
-  thrift_spec = (
-    None, # 0
-    (1, TType.I64, 'trackerId', None, None, ), # 1
-  )
-  def __init__(self, trackerId=None,):
-    self.trackerId = trackerId
-  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.trackerId = 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('getTrackerById_args')
-    if self.trackerId != None:
-      oprot.writeFieldBegin('trackerId', TType.I64, 1)
-      oprot.writeI64(self.trackerId)
-      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 getTrackerById_result:
   """
   Attributes:
    - success
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getTrackersByAffiliate_args:
+class getAffiliatesByMasterAffiliate_args:
   """
   Attributes:
-   - affiliateId
+   - id
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'affiliateId', None, None, ), # 1
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
-  def __init__(self, affiliateId=None,):
+  def __init__(self, id=None,):
-    self.affiliateId = affiliateId
+    self.id = id
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.affiliateId = iprot.readI64();
+          self.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('getTrackersByAffiliate_args')
+    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
-    if self.affiliateId != None:
+    if self.id != None:
-      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
+      oprot.writeFieldBegin('id', TType.I64, 1)
-      oprot.writeI64(self.affiliateId)
+      oprot.writeI64(self.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 getTrackersByAffiliate_result:
+class getAffiliatesByMasterAffiliate_result:
   """
   Attributes:
    - success
    - utx
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Tracker, Tracker.thrift_spec)), None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype73, _size70) = iprot.readListBegin()
+          (_etype66, _size63) = iprot.readListBegin()
-          for _i74 in xrange(_size70):
+          for _i67 in xrange(_size63):
-            _elem75 = Tracker()
+            _elem68 = Affiliate()
-            _elem75.read(iprot)
+            _elem68.read(iprot)
-            self.success.append(_elem75)
+            self.success.append(_elem68)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
   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('getTrackersByAffiliate_result')
+    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter76 in self.success:
+      for iter69 in self.success:
-        iter76.write(oprot)
+        iter69.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx != None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
     return not (self == other)
 class addTrackLog_args:
   """
   Attributes:
-   - trackerId
+   - affiliateId
    - userId
    - event
    - url
    - data
    - addedOn
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'trackerId', None, None, ), # 1
+    (1, TType.I64, 'affiliateId', None, None, ), # 1
     (2, TType.I64, 'userId', None, None, ), # 2
     (3, TType.STRING, 'event', None, None, ), # 3
     (4, TType.STRING, 'url', None, None, ), # 4
     (5, TType.STRING, 'data', None, None, ), # 5
     (6, TType.I64, 'addedOn', None, None, ), # 6
+  )
-  def __init__(self, trackerId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
+  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
-    self.trackerId = trackerId
+    self.affiliateId = affiliateId
     self.userId = userId
     self.event = event
     self.url = url
     self.data = data
     self.addedOn = addedOn
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.trackerId = iprot.readI64();
+          self.affiliateId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
           self.userId = iprot.readI64();
   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('addTrackLog_args')
-    if self.trackerId != None:
+    if self.affiliateId != None:
-      oprot.writeFieldBegin('trackerId', TType.I64, 1)
+      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
-      oprot.writeI64(self.trackerId)
+      oprot.writeI64(self.affiliateId)
       oprot.writeFieldEnd()
     if self.userId != None:
       oprot.writeFieldBegin('userId', TType.I64, 2)
       oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
    - utx
   """
   thrift_spec = (
     (0, TType.I64, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
    - utx
   """
   thrift_spec = (
     (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
           self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getTrackLogsByTracker_args:
+class getTrackLogsByAffiliate_args:
   """
   Attributes:
-   - trackerId
+   - affiliateId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'trackerId', None, None, ), # 1
+    (1, TType.I64, 'affiliateId', None, None, ), # 1
+  )
-  def __init__(self, trackerId=None,):
+  def __init__(self, affiliateId=None,):
-    self.trackerId = trackerId
+    self.affiliateId = affiliateId
   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.trackerId = iprot.readI64();
+          self.affiliateId = 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('getTrackLogsByTracker_args')
+    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
-    if self.trackerId != None:
+    if self.affiliateId != None:
-      oprot.writeFieldBegin('trackerId', TType.I64, 1)
+      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
-      oprot.writeI64(self.trackerId)
+      oprot.writeI64(self.affiliateId)
       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 getTrackLogsByTracker_result:
+class getTrackLogsByAffiliate_result:
   """
   Attributes:
    - success
    - utx
   """
   thrift_spec = (
     (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype80, _size77) = iprot.readListBegin()
+          (_etype73, _size70) = iprot.readListBegin()
-          for _i81 in xrange(_size77):
+          for _i74 in xrange(_size70):
-            _elem82 = TrackLog()
+            _elem75 = TrackLog()
-            _elem82.read(iprot)
+            _elem75.read(iprot)
-            self.success.append(_elem82)
+            self.success.append(_elem75)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
   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('getTrackLogsByTracker_result')
+    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter83 in self.success:
+      for iter76 in self.success:
-        iter83.write(oprot)
+        iter76.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx != None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
    - utx
   """
   thrift_spec = (
     (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype87, _size84) = iprot.readListBegin()
+          (_etype80, _size77) = iprot.readListBegin()
-          for _i88 in xrange(_size84):
+          for _i81 in xrange(_size77):
-            _elem89 = TrackLog()
+            _elem82 = TrackLog()
-            _elem89.read(iprot)
+            _elem82.read(iprot)
-            self.success.append(_elem89)
+            self.success.append(_elem82)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getTrackLogsByUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter90 in self.success:
+      for iter83 in self.success:
-        iter90.write(oprot)
+        iter83.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx != None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
     return not (self == other)
 class getTrackLogs_args:
   """
   Attributes:
-   - trackerId
    - userId
    - event
    - url
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'trackerId', None, None, ), # 1
-    (2, TType.I64, 'userId', None, None, ), # 2
+    (1, TType.I64, 'userId', None, None, ), # 1
-    (3, TType.STRING, 'event', None, None, ), # 3
+    (2, TType.STRING, 'event', None, None, ), # 2
-    (4, TType.STRING, 'url', None, None, ), # 4
+    (3, TType.STRING, 'url', None, None, ), # 3
+  )
-  def __init__(self, trackerId=None, userId=None, event=None, url=None,):
+  def __init__(self, userId=None, event=None, url=None,):
-    self.trackerId = trackerId
     self.userId = userId
     self.event = event
     self.url = url
   def read(self, iprot):
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.trackerId = iprot.readI64();
-        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.STRING:
           self.event = iprot.readString();
         else:
           iprot.skip(ftype)
-      elif fid == 4:
+      elif fid == 3:
         if ftype == TType.STRING:
           self.url = iprot.readString();
         else:
           iprot.skip(ftype)
       else:
   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('getTrackLogs_args')
-    if self.trackerId != None:
-      oprot.writeFieldBegin('trackerId', TType.I64, 1)
-      oprot.writeI64(self.trackerId)
-      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.event != None:
-      oprot.writeFieldBegin('event', TType.STRING, 3)
+      oprot.writeFieldBegin('event', TType.STRING, 2)
       oprot.writeString(self.event)
       oprot.writeFieldEnd()
     if self.url != None:
-      oprot.writeFieldBegin('url', TType.STRING, 4)
+      oprot.writeFieldBegin('url', TType.STRING, 3)
       oprot.writeString(self.url)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
    - utx
   """
   thrift_spec = (
     (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
+    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, utx=None,):
     self.success = success
     self.utx = utx
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype94, _size91) = iprot.readListBegin()
+          (_etype87, _size84) = iprot.readListBegin()
-          for _i95 in xrange(_size91):
+          for _i88 in xrange(_size84):
-            _elem96 = TrackLog()
+            _elem89 = TrackLog()
-            _elem96.read(iprot)
+            _elem89.read(iprot)
-            self.success.append(_elem96)
+            self.success.append(_elem89)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
-          self.utx = UserTrackerException()
+          self.utx = UserAffiliateException()
           self.utx.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getTrackLogs_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter97 in self.success:
+      for iter90 in self.success:
-        iter97.write(oprot)
+        iter90.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.utx != None:
       oprot.writeFieldBegin('utx', TType.STRUCT, 1)
       self.utx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype101, _size98) = iprot.readListBegin()
+          (_etype94, _size91) = iprot.readListBegin()
-          for _i102 in xrange(_size98):
+          for _i95 in xrange(_size91):
-            _elem103 = Cart()
+            _elem96 = Cart()
-            _elem103.read(iprot)
+            _elem96.read(iprot)
-            self.success.append(_elem103)
+            self.success.append(_elem96)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCartsForUser_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter104 in self.success:
+      for iter97 in self.success:
-        iter104.write(oprot)
+        iter97.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.scx != None:
       oprot.writeFieldBegin('scx', TType.STRUCT, 1)
       self.scx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype108, _size105) = iprot.readListBegin()
+          (_etype101, _size98) = iprot.readListBegin()
-          for _i109 in xrange(_size105):
+          for _i102 in xrange(_size98):
-            _elem110 = Cart()
+            _elem103 = Cart()
-            _elem110.read(iprot)
+            _elem103.read(iprot)
-            self.success.append(_elem110)
+            self.success.append(_elem103)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCartsByStatus_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter111 in self.success:
+      for iter104 in self.success:
-        iter111.write(oprot)
+        iter104.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.scx != None:
       oprot.writeFieldBegin('scx', TType.STRUCT, 1)
       self.scx.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype115, _size112) = iprot.readListBegin()
+          (_etype108, _size105) = iprot.readListBegin()
-          for _i116 in xrange(_size112):
+          for _i109 in xrange(_size105):
-            _elem117 = Cart()
+            _elem110 = Cart()
-            _elem117.read(iprot)
+            _elem110.read(iprot)
-            self.success.append(_elem117)
+            self.success.append(_elem110)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCartsByTime_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter118 in self.success:
+      for iter111 in self.success:
-        iter118.write(oprot)
+        iter111.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.scx != None:
       oprot.writeFieldBegin('scx', TType.STRUCT, 1)
       self.scx.write(oprot)
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.items = {}
-          (_ktype120, _vtype121, _size119 ) = iprot.readMapBegin()
+          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
-          for _i123 in xrange(_size119):
+          for _i116 in xrange(_size112):
-            _key124 = iprot.readI64();
+            _key117 = iprot.readI64();
-            _val125 = iprot.readDouble();
+            _val118 = iprot.readDouble();
-            self.items[_key124] = _val125
+            self.items[_key117] = _val118
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.cartId)
       oprot.writeFieldEnd()
     if self.items != None:
       oprot.writeFieldBegin('items', TType.MAP, 2)
       oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
-      for kiter126,viter127 in self.items.items():
+      for kiter119,viter120 in self.items.items():
-        oprot.writeI64(kiter126)
+        oprot.writeI64(kiter119)
-        oprot.writeDouble(viter127)
+        oprot.writeDouble(viter120)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype131, _size128) = iprot.readListBegin()
+          (_etype124, _size121) = iprot.readListBegin()
-          for _i132 in xrange(_size128):
+          for _i125 in xrange(_size121):
-            _elem133 = User()
+            _elem126 = User()
-            _elem133.read(iprot)
+            _elem126.read(iprot)
-            self.success.append(_elem133)
+            self.success.append(_elem126)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllUsers_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter134 in self.success:
+      for iter127 in self.success:
-        iter134.write(oprot)
+        iter127.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()

Subversion Repositories SmartDukaan

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