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

     pass
   def getAllUserCommunications(self, ):
     pass
+  def createMasterAffiliate(self, name):
+    """
+    Parameters:
+     - name
+    """
+    pass
+  def getMasterAffiliateById(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def getMasterAffiliateByName(self, name):
+    """
+    Parameters:
+     - name
+    """
+    pass
+  def createAffiliate(self, name, url, masterAffiliateId):
+    """
+    Parameters:
+     - name
+     - url
+     - masterAffiliateId
+    """
+    pass
+  def getAffiliateById(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def getAffiliateByName(self, name):
+    """
+    Parameters:
+     - name
+    """
+    pass
+  def getAffiliatesByMasterAffiliate(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def createTracker(self, affiliateId):
+    """
+    Parameters:
+     - affiliateId
+    """
+    pass
+  def getTrackerById(self, trackerId):
+    """
+    Parameters:
+     - trackerId
+    """
+    pass
+  def getTrackersByAffiliate(self, affiliateId):
+    """
+    Parameters:
+     - affiliateId
+    """
+    pass
+  def addTrackLog(self, trackerId, userId, event, url, data):
+    """
+    Parameters:
+     - trackerId
+     - userId
+     - event
+     - url
+     - data
+    """
+    pass
+  def getTrackLogById(self, id):
+    """
+    Parameters:
+     - id
+    """
+    pass
+  def getTrackLogsByTracker(self, trackerId):
+    """
+    Parameters:
+     - trackerId
+    """
+    pass
+  def getTrackLogsByUser(self, userId):
+    """
+    Parameters:
+     - userId
+    """
+    pass
+  def getTrackLogs(self, trackerId, userId, event, url):
+    """
+    Parameters:
+     - trackerId
+     - userId
+     - event
+     - url
+    """
+    pass
   def createCart(self, userId):
     """
     Parameters:
      - userId
     """
       return result.success
     if result.ucx != None:
       raise result.ucx
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
+  def createMasterAffiliate(self, name):
+    """
+    Parameters:
+     - name
+    """
+    self.send_createMasterAffiliate(name)
+    return self.recv_createMasterAffiliate()
+  def send_createMasterAffiliate(self, name):
+    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
+    args = createMasterAffiliate_args()
+    args.name = name
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_createMasterAffiliate(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createMasterAffiliate_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, "createMasterAffiliate failed: unknown result");
+  def getMasterAffiliateById(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_getMasterAffiliateById(id)
+    return self.recv_getMasterAffiliateById()
+  def send_getMasterAffiliateById(self, id):
+    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
+    args = getMasterAffiliateById_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getMasterAffiliateById(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getMasterAffiliateById_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, "getMasterAffiliateById failed: unknown result");
+  def getMasterAffiliateByName(self, name):
+    """
+    Parameters:
+     - name
+    """
+    self.send_getMasterAffiliateByName(name)
+    return self.recv_getMasterAffiliateByName()
+  def send_getMasterAffiliateByName(self, name):
+    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
+    args = getMasterAffiliateByName_args()
+    args.name = name
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getMasterAffiliateByName(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getMasterAffiliateByName_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, "getMasterAffiliateByName failed: unknown result");
+  def createAffiliate(self, name, url, masterAffiliateId):
+    """
+    Parameters:
+     - name
+     - url
+     - masterAffiliateId
+    """
+    self.send_createAffiliate(name, url, masterAffiliateId)
+    return self.recv_createAffiliate()
+  def send_createAffiliate(self, name, url, masterAffiliateId):
+    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
+    args = createAffiliate_args()
+    args.name = name
+    args.url = url
+    args.masterAffiliateId = masterAffiliateId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_createAffiliate(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createAffiliate_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, "createAffiliate failed: unknown result");
+  def getAffiliateById(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_getAffiliateById(id)
+    return self.recv_getAffiliateById()
+  def send_getAffiliateById(self, id):
+    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
+    args = getAffiliateById_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getAffiliateById(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAffiliateById_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, "getAffiliateById failed: unknown result");
+  def getAffiliateByName(self, name):
+    """
+    Parameters:
+     - name
+    """
+    self.send_getAffiliateByName(name)
+    return self.recv_getAffiliateByName()
+  def send_getAffiliateByName(self, name):
+    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
+    args = getAffiliateByName_args()
+    args.name = name
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getAffiliateByName(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAffiliateByName_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, "getAffiliateByName failed: unknown result");
+  def getAffiliatesByMasterAffiliate(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):
+    """
+    Parameters:
+     - affiliateId
+    """
+    self.send_createTracker(affiliateId)
+    return self.recv_createTracker()
+  def send_createTracker(self, affiliateId):
+    self._oprot.writeMessageBegin('createTracker', TMessageType.CALL, self._seqid)
+    args = createTracker_args()
+    args.affiliateId = affiliateId
+    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)
+    return self.recv_getTrackerById()
+  def send_getTrackerById(self, trackerId):
+    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
+    args = getTrackerById_args()
+    args.trackerId = trackerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTrackerById(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTrackerById_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, "getTrackerById failed: unknown result");
+  def getTrackersByAffiliate(self, affiliateId):
+    """
+    Parameters:
+     - affiliateId
+    """
+    self.send_getTrackersByAffiliate(affiliateId)
+    return self.recv_getTrackersByAffiliate()
+  def send_getTrackersByAffiliate(self, affiliateId):
+    self._oprot.writeMessageBegin('getTrackersByAffiliate', TMessageType.CALL, self._seqid)
+    args = getTrackersByAffiliate_args()
+    args.affiliateId = affiliateId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTrackersByAffiliate(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.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");
+  def addTrackLog(self, trackerId, userId, event, url, data):
+    """
+    Parameters:
+     - trackerId
+     - userId
+     - event
+     - url
+     - data
+    """
+    self.send_addTrackLog(trackerId, userId, event, url, data)
+    return self.recv_addTrackLog()
+  def send_addTrackLog(self, trackerId, userId, event, url, data):
+    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
+    args = addTrackLog_args()
+    args.trackerId = trackerId
+    args.userId = userId
+    args.event = event
+    args.url = url
+    args.data = data
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_addTrackLog(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = addTrackLog_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, "addTrackLog failed: unknown result");
+  def getTrackLogById(self, id):
+    """
+    Parameters:
+     - id
+    """
+    self.send_getTrackLogById(id)
+    return self.recv_getTrackLogById()
+  def send_getTrackLogById(self, id):
+    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
+    args = getTrackLogById_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTrackLogById(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTrackLogById_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, "getTrackLogById failed: unknown result");
+  def getTrackLogsByTracker(self, trackerId):
+    """
+    Parameters:
+     - trackerId
+    """
+    self.send_getTrackLogsByTracker(trackerId)
+    return self.recv_getTrackLogsByTracker()
+  def send_getTrackLogsByTracker(self, trackerId):
+    self._oprot.writeMessageBegin('getTrackLogsByTracker', TMessageType.CALL, self._seqid)
+    args = getTrackLogsByTracker_args()
+    args.trackerId = trackerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTrackLogsByTracker(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.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");
+  def getTrackLogsByUser(self, userId):
+    """
+    Parameters:
+     - userId
+    """
+    self.send_getTrackLogsByUser(userId)
+    return self.recv_getTrackLogsByUser()
+  def send_getTrackLogsByUser(self, userId):
+    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
+    args = getTrackLogsByUser_args()
+    args.userId = userId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getTrackLogsByUser(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTrackLogsByUser_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, "getTrackLogsByUser failed: unknown result");
+  def getTrackLogs(self, trackerId, userId, event, url):
+    """
+    Parameters:
+     - trackerId
+     - userId
+     - event
+     - url
+    """
+    self.send_getTrackLogs(trackerId, userId, event, url)
+    return self.recv_getTrackLogs()
+  def send_getTrackLogs(self, trackerId, 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._oprot.trans.flush()
+  def recv_getTrackLogs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTrackLogs_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, "getTrackLogs failed: unknown result");
   def createCart(self, userId):
     """
     Parameters:
      - userId
     """
     self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
     self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
     self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
     self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
     self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
+    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
+    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["addTrackLog"] = Processor.process_addTrackLog
+    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
+    self._processMap["getTrackLogsByTracker"] = Processor.process_getTrackLogsByTracker
+    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
+    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
     self._processMap["createCart"] = Processor.process_createCart
     self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
     self._processMap["getCart"] = Processor.process_getCart
     self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
     self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
     oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_createMasterAffiliate(self, seqid, iprot, oprot):
+    args = createMasterAffiliate_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createMasterAffiliate_result()
+    try:
+      result.success = self._handler.createMasterAffiliate(args.name)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
+    args = getMasterAffiliateById_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getMasterAffiliateById_result()
+    try:
+      result.success = self._handler.getMasterAffiliateById(args.id)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
+    args = getMasterAffiliateByName_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getMasterAffiliateByName_result()
+    try:
+      result.success = self._handler.getMasterAffiliateByName(args.name)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_createAffiliate(self, seqid, iprot, oprot):
+    args = createAffiliate_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createAffiliate_result()
+    try:
+      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getAffiliateById(self, seqid, iprot, oprot):
+    args = getAffiliateById_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAffiliateById_result()
+    try:
+      result.success = self._handler.getAffiliateById(args.id)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getAffiliateByName(self, seqid, iprot, oprot):
+    args = getAffiliateByName_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAffiliateByName_result()
+    try:
+      result.success = self._handler.getAffiliateByName(args.name)
+    except UserTrackerException, 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)
+    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)
+    except UserTrackerException, 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):
+    args = getTrackersByAffiliate_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTrackersByAffiliate_result()
+    try:
+      result.success = self._handler.getTrackersByAffiliate(args.affiliateId)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getTrackersByAffiliate", 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)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getTrackLogById(self, seqid, iprot, oprot):
+    args = getTrackLogById_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTrackLogById_result()
+    try:
+      result.success = self._handler.getTrackLogById(args.id)
+    except UserTrackerException, 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):
+    args = getTrackLogsByTracker_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTrackLogsByTracker_result()
+    try:
+      result.success = self._handler.getTrackLogsByTracker(args.trackerId)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getTrackLogsByTracker", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
+    args = getTrackLogsByUser_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTrackLogsByUser_result()
+    try:
+      result.success = self._handler.getTrackLogsByUser(args.userId)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getTrackLogs(self, seqid, iprot, oprot):
+    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)
+    except UserTrackerException, utx:
+      result.utx = utx
+    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_createCart(self, seqid, iprot, oprot):
     args = createCart_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = createCart_result()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class createMasterAffiliate_args:
+  """
+  Attributes:
+   - name
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+  )
+  def __init__(self, name=None,):
+    self.name = name
+  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.STRING:
+          self.name = 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('createMasterAffiliate_args')
+    if self.name != None:
+      oprot.writeFieldBegin('name', TType.STRING, 1)
+      oprot.writeString(self.name)
+      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 createMasterAffiliate_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.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 = MasterAffiliate()
+          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('createMasterAffiliate_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 getMasterAffiliateById_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    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
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.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('getMasterAffiliateById_args')
+    if self.id != None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.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 getMasterAffiliateById_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.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 = MasterAffiliate()
+          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('getMasterAffiliateById_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 getMasterAffiliateByName_args:
+  """
+  Attributes:
+   - name
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+  )
+  def __init__(self, name=None,):
+    self.name = name
+  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.STRING:
+          self.name = 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('getMasterAffiliateByName_args')
+    if self.name != None:
+      oprot.writeFieldBegin('name', TType.STRING, 1)
+      oprot.writeString(self.name)
+      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 getMasterAffiliateByName_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.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 = MasterAffiliate()
+          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('getMasterAffiliateByName_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 createAffiliate_args:
+  """
+  Attributes:
+   - name
+   - url
+   - masterAffiliateId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+    (2, TType.STRING, 'url', None, None, ), # 2
+    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
+  )
+  def __init__(self, name=None, url=None, masterAffiliateId=None,):
+    self.name = name
+    self.url = url
+    self.masterAffiliateId = masterAffiliateId
+  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.STRING:
+          self.name = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.url = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.masterAffiliateId = 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('createAffiliate_args')
+    if self.name != None:
+      oprot.writeFieldBegin('name', TType.STRING, 1)
+      oprot.writeString(self.name)
+      oprot.writeFieldEnd()
+    if self.url != None:
+      oprot.writeFieldBegin('url', TType.STRING, 2)
+      oprot.writeString(self.url)
+      oprot.writeFieldEnd()
+    if self.masterAffiliateId != None:
+      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
+      oprot.writeI64(self.masterAffiliateId)
+      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 createAffiliate_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (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.STRUCT:
+          self.success = Affiliate()
+          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('createAffiliate_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 getAffiliateById_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    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
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.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('getAffiliateById_args')
+    if self.id != None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.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 getAffiliateById_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (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.STRUCT:
+          self.success = Affiliate()
+          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('getAffiliateById_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 getAffiliateByName_args:
+  """
+  Attributes:
+   - name
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'name', None, None, ), # 1
+  )
+  def __init__(self, name=None,):
+    self.name = name
+  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.STRING:
+          self.name = 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('getAffiliateByName_args')
+    if self.name != None:
+      oprot.writeFieldBegin('name', TType.STRING, 1)
+      oprot.writeString(self.name)
+      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 getAffiliateByName_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (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.STRUCT:
+          self.success = Affiliate()
+          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('getAffiliateByName_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 getAffiliatesByMasterAffiliate_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    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
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.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('getAffiliatesByMasterAffiliate_args')
+    if self.id != None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.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 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 = []
+          (_etype52, _size49) = iprot.readListBegin()
+          for _i53 in xrange(_size49):
+            _elem54 = Affiliate()
+            _elem54.read(iprot)
+            self.success.append(_elem54)
+          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 iter55 in self.success:
+        iter55.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
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'affiliateId', None, None, ), # 1
+  )
+  def __init__(self, affiliateId=None,):
+    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
+    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)
+      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()
+    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
+  )
+  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('getTrackerById_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 getTrackersByAffiliate_args:
+  """
+  Attributes:
+   - affiliateId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'affiliateId', None, None, ), # 1
+  )
+  def __init__(self, affiliateId=None,):
+    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
+    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)
+      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('getTrackersByAffiliate_args')
+    if self.affiliateId != None:
+      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
+      oprot.writeI64(self.affiliateId)
+      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 getTrackersByAffiliate_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(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.LIST:
+          self.success = []
+          (_etype59, _size56) = iprot.readListBegin()
+          for _i60 in xrange(_size56):
+            _elem61 = Tracker()
+            _elem61.read(iprot)
+            self.success.append(_elem61)
+          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('getTrackersByAffiliate_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter62 in self.success:
+        iter62.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 addTrackLog_args:
+  """
+  Attributes:
+   - trackerId
+   - userId
+   - event
+   - url
+   - data
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'trackerId', 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
+  )
+  def __init__(self, trackerId=None, userId=None, event=None, url=None, data=None,):
+    self.trackerId = trackerId
+    self.userId = userId
+    self.event = event
+    self.url = url
+    self.data = data
+  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)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.event = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.url = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
+          self.data = 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('addTrackLog_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.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.event != None:
+      oprot.writeFieldBegin('event', TType.STRING, 3)
+      oprot.writeString(self.event)
+      oprot.writeFieldEnd()
+    if self.url != None:
+      oprot.writeFieldBegin('url', TType.STRING, 4)
+      oprot.writeString(self.url)
+      oprot.writeFieldEnd()
+    if self.data != None:
+      oprot.writeFieldBegin('data', TType.STRING, 5)
+      oprot.writeString(self.data)
+      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 addTrackLog_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.I64, 'success', None, 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.I64:
+          self.success = iprot.readI64();
+        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('addTrackLog_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.I64, 0)
+      oprot.writeI64(self.success)
+      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 getTrackLogById_args:
+  """
+  Attributes:
+   - id
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
+  def __init__(self, id=None,):
+    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
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.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('getTrackLogById_args')
+    if self.id != None:
+      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeI64(self.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 getTrackLogById_result:
+  """
+  Attributes:
+   - success
+   - utx
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.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 = TrackLog()
+          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('getTrackLogById_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 getTrackLogsByTracker_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('getTrackLogsByTracker_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 getTrackLogsByTracker_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
+  )
+  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 = TrackLog()
+            _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('getTrackLogsByTracker_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 getTrackLogsByUser_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('getTrackLogsByUser_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 getTrackLogsByUser_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
+  )
+  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 = []
+          (_etype73, _size70) = iprot.readListBegin()
+          for _i74 in xrange(_size70):
+            _elem75 = TrackLog()
+            _elem75.read(iprot)
+            self.success.append(_elem75)
+          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('getTrackLogsByUser_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter76 in self.success:
+        iter76.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 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
+    (3, TType.STRING, 'event', None, None, ), # 3
+    (4, TType.STRING, 'url', None, None, ), # 4
+  )
+  def __init__(self, trackerId=None, userId=None, event=None, url=None,):
+    self.trackerId = trackerId
+    self.userId = userId
+    self.event = event
+    self.url = url
+  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)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.STRING:
+          self.event = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.url = 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('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.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.event != None:
+      oprot.writeFieldBegin('event', TType.STRING, 3)
+      oprot.writeString(self.event)
+      oprot.writeFieldEnd()
+    if self.url != None:
+      oprot.writeFieldBegin('url', TType.STRING, 4)
+      oprot.writeString(self.url)
+      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 getTrackLogs_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
+  )
+  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 = []
+          (_etype80, _size77) = iprot.readListBegin()
+          for _i81 in xrange(_size77):
+            _elem82 = TrackLog()
+            _elem82.read(iprot)
+            self.success.append(_elem82)
+          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('getTrackLogs_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter83 in self.success:
+        iter83.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 createCart_args:
   """
   Attributes:
    - userId
   """
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype52, _size49) = iprot.readListBegin()
+          (_etype87, _size84) = iprot.readListBegin()
-          for _i53 in xrange(_size49):
+          for _i88 in xrange(_size84):
-            _elem54 = Cart()
+            _elem89 = Cart()
-            _elem54.read(iprot)
+            _elem89.read(iprot)
-            self.success.append(_elem54)
+            self.success.append(_elem89)
           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 iter55 in self.success:
+      for iter90 in self.success:
-        iter55.write(oprot)
+        iter90.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 = []
-          (_etype59, _size56) = iprot.readListBegin()
+          (_etype94, _size91) = iprot.readListBegin()
-          for _i60 in xrange(_size56):
+          for _i95 in xrange(_size91):
-            _elem61 = Cart()
+            _elem96 = Cart()
-            _elem61.read(iprot)
+            _elem96.read(iprot)
-            self.success.append(_elem61)
+            self.success.append(_elem96)
           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 iter62 in self.success:
+      for iter97 in self.success:
-        iter62.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 = []
-          (_etype66, _size63) = iprot.readListBegin()
+          (_etype101, _size98) = iprot.readListBegin()
-          for _i67 in xrange(_size63):
+          for _i102 in xrange(_size98):
-            _elem68 = Cart()
+            _elem103 = Cart()
-            _elem68.read(iprot)
+            _elem103.read(iprot)
-            self.success.append(_elem68)
+            self.success.append(_elem103)
           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 iter69 in self.success:
+      for iter104 in self.success:
-        iter69.write(oprot)
+        iter104.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 = {}
-          (_ktype71, _vtype72, _size70 ) = iprot.readMapBegin()
+          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
-          for _i74 in xrange(_size70):
+          for _i109 in xrange(_size105):
-            _key75 = iprot.readI64();
+            _key110 = iprot.readI64();
-            _val76 = iprot.readDouble();
+            _val111 = iprot.readDouble();
-            self.items[_key75] = _val76
+            self.items[_key110] = _val111
           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 kiter77,viter78 in self.items.items():
+      for kiter112,viter113 in self.items.items():
-        oprot.writeI64(kiter77)
+        oprot.writeI64(kiter112)
-        oprot.writeDouble(viter78)
+        oprot.writeDouble(viter113)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype82, _size79) = iprot.readListBegin()
+          (_etype117, _size114) = iprot.readListBegin()
-          for _i83 in xrange(_size79):
+          for _i118 in xrange(_size114):
-            _elem84 = User()
+            _elem119 = User()
-            _elem84.read(iprot)
+            _elem119.read(iprot)
-            self.success.append(_elem84)
+            self.success.append(_elem119)
           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 iter85 in self.success:
+      for iter120 in self.success:
-        iter85.write(oprot)
+        iter120.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 1673 → 1845