WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/thriftpy/model/v1/catalog/CatalogService.py

     pass
   def getAllEntityTags(self, ):
     pass
-  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
+  def addBanner(self, banner):
     """
+    Banner Related
     Parameters:
-     - bannerName
+     - banner
-     - imageName
+    """
-     - link
+    pass
+  def updateBanner(self, banner):
-     - priority
+    """
-     - isActive
+    Parameters:
-     - hasMap
+     - banner
     """
     pass
   def getAllBanners(self, ):
     pass
     pass
   def getActiveBanners(self, ):
     pass
-  def addBannerMap(self, bannerName, mapLink, coordinates):
+  def addBannerMap(self, bannerMaps):
     """
     Parameters:
-     - bannerName
+     - bannerMaps
+    """
+    pass
+  def updateBannerMap(self, bannerMap):
+    """
-     - mapLink
+    Parameters:
-     - coordinates
+     - bannerMap
     """
     pass
   def deleteBannerMap(self, bannerName):
     """
     Parameters:
      - bannerName
     """
     pass
+  def addBannerUri(self, bannerUriMappings):
+    """
+    Parameters:
+     - bannerUriMappings
+    """
+    pass
+  def getUriMapping(self, bannerName):
+    """
+    Parameters:
+     - bannerName
+    """
+    pass
+  def addCampaign(self, campaign):
+    """
+    Parameters:
+     - campaign
+    """
+    pass
+  def getCampaigns(self, campaignName):
+    """
+    Parameters:
+     - campaignName
+    """
+    pass
+  def deleteCampaign(self, campaignId):
+    """
+    Parameters:
+     - campaignId
+    """
+    pass
+  def getAllCampaigns(self, ):
+    pass
   def deleteSimilarItem(self, itemId, catalogItemId):
     """
     Delete similar item.
     Parameters:
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
-  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
+  def addBanner(self, banner):
     """
+    Banner Related
     Parameters:
-     - bannerName
+     - banner
-     - imageName
-     - link
-     - priority
-     - isActive
-     - hasMap
     """
-    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
+    self.send_addBanner(banner)
     return self.recv_addBanner()
-  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
+  def send_addBanner(self, banner):
     self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
     args = addBanner_args()
-    args.bannerName = bannerName
+    args.banner = banner
-    args.imageName = imageName
-    args.link = link
-    args.priority = priority
-    args.isActive = isActive
-    args.hasMap = hasMap
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_addBanner(self, ):
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
+  def updateBanner(self, banner):
+    """
+    Parameters:
+     - banner
+    """
+    self.send_updateBanner(banner)
+    return self.recv_updateBanner()
+  def send_updateBanner(self, banner):
+    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
+    args = updateBanner_args()
+    args.banner = banner
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateBanner(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateBanner_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
   def getAllBanners(self, ):
     self.send_getAllBanners()
     return self.recv_getAllBanners()
   def send_getAllBanners(self, ):
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
-  def addBannerMap(self, bannerName, mapLink, coordinates):
+  def addBannerMap(self, bannerMaps):
     """
     Parameters:
-     - bannerName
+     - bannerMaps
-     - mapLink
-     - coordinates
     """
-    self.send_addBannerMap(bannerName, mapLink, coordinates)
+    self.send_addBannerMap(bannerMaps)
     return self.recv_addBannerMap()
-  def send_addBannerMap(self, bannerName, mapLink, coordinates):
+  def send_addBannerMap(self, bannerMaps):
     self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
     args = addBannerMap_args()
-    args.bannerName = bannerName
+    args.bannerMaps = bannerMaps
-    args.mapLink = mapLink
-    args.coordinates = coordinates
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_addBannerMap(self, ):
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
+  def updateBannerMap(self, bannerMap):
+    """
+    Parameters:
+     - bannerMap
+    """
+    self.send_updateBannerMap(bannerMap)
+    return self.recv_updateBannerMap()
+  def send_updateBannerMap(self, bannerMap):
+    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
+    args = updateBannerMap_args()
+    args.bannerMap = bannerMap
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateBannerMap(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateBannerMap_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
   def deleteBannerMap(self, bannerName):
     """
     Parameters:
      - bannerName
     """
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
+  def addBannerUri(self, bannerUriMappings):
+    """
+    Parameters:
+     - bannerUriMappings
+    """
+    self.send_addBannerUri(bannerUriMappings)
+    self.recv_addBannerUri()
+  def send_addBannerUri(self, bannerUriMappings):
+    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
+    args = addBannerUri_args()
+    args.bannerUriMappings = bannerUriMappings
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_addBannerUri(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = addBannerUri_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getUriMapping(self, bannerName):
+    """
+    Parameters:
+     - bannerName
+    """
+    self.send_getUriMapping(bannerName)
+    return self.recv_getUriMapping()
+  def send_getUriMapping(self, bannerName):
+    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
+    args = getUriMapping_args()
+    args.bannerName = bannerName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getUriMapping(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getUriMapping_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
+  def addCampaign(self, campaign):
+    """
+    Parameters:
+     - campaign
+    """
+    self.send_addCampaign(campaign)
+    self.recv_addCampaign()
+  def send_addCampaign(self, campaign):
+    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
+    args = addCampaign_args()
+    args.campaign = campaign
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_addCampaign(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = addCampaign_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getCampaigns(self, campaignName):
+    """
+    Parameters:
+     - campaignName
+    """
+    self.send_getCampaigns(campaignName)
+    return self.recv_getCampaigns()
+  def send_getCampaigns(self, campaignName):
+    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
+    args = getCampaigns_args()
+    args.campaignName = campaignName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getCampaigns(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getCampaigns_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
+  def deleteCampaign(self, campaignId):
+    """
+    Parameters:
+     - campaignId
+    """
+    self.send_deleteCampaign(campaignId)
+    self.recv_deleteCampaign()
+  def send_deleteCampaign(self, campaignId):
+    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
+    args = deleteCampaign_args()
+    args.campaignId = campaignId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_deleteCampaign(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteCampaign_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getAllCampaigns(self, ):
+    self.send_getAllCampaigns()
+    return self.recv_getAllCampaigns()
+  def send_getAllCampaigns(self, ):
+    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
+    args = getAllCampaigns_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getAllCampaigns(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAllCampaigns_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
   def deleteSimilarItem(self, itemId, catalogItemId):
     """
     Delete similar item.
     Parameters:
     self._processMap["deleteTag"] = Processor.process_deleteTag
     self._processMap["getAllTags"] = Processor.process_getAllTags
     self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
     self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
     self._processMap["addBanner"] = Processor.process_addBanner
+    self._processMap["updateBanner"] = Processor.process_updateBanner
     self._processMap["getAllBanners"] = Processor.process_getAllBanners
     self._processMap["deleteBanner"] = Processor.process_deleteBanner
     self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
     self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
     self._processMap["addBannerMap"] = Processor.process_addBannerMap
+    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
     self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
     self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
+    self._processMap["addBannerUri"] = Processor.process_addBannerUri
+    self._processMap["getUriMapping"] = Processor.process_getUriMapping
+    self._processMap["addCampaign"] = Processor.process_addCampaign
+    self._processMap["getCampaigns"] = Processor.process_getCampaigns
+    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
+    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
     self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
     self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
     self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
     self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
     self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
   def process_addBanner(self, seqid, iprot, oprot):
     args = addBanner_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = addBanner_result()
-    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
+    result.success = self._handler.addBanner(args.banner)
     oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_updateBanner(self, seqid, iprot, oprot):
+    args = updateBanner_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateBanner_result()
+    result.success = self._handler.updateBanner(args.banner)
+    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_getAllBanners(self, seqid, iprot, oprot):
     args = getAllBanners_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getAllBanners_result()
   def process_addBannerMap(self, seqid, iprot, oprot):
     args = addBannerMap_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = addBannerMap_result()
-    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
+    result.success = self._handler.addBannerMap(args.bannerMaps)
     oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_updateBannerMap(self, seqid, iprot, oprot):
+    args = updateBannerMap_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateBannerMap_result()
+    result.success = self._handler.updateBannerMap(args.bannerMap)
+    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_deleteBannerMap(self, seqid, iprot, oprot):
     args = deleteBannerMap_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = deleteBannerMap_result()
     oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_addBannerUri(self, seqid, iprot, oprot):
+    args = addBannerUri_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addBannerUri_result()
+    self._handler.addBannerUri(args.bannerUriMappings)
+    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getUriMapping(self, seqid, iprot, oprot):
+    args = getUriMapping_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getUriMapping_result()
+    result.success = self._handler.getUriMapping(args.bannerName)
+    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_addCampaign(self, seqid, iprot, oprot):
+    args = addCampaign_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = addCampaign_result()
+    self._handler.addCampaign(args.campaign)
+    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getCampaigns(self, seqid, iprot, oprot):
+    args = getCampaigns_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getCampaigns_result()
+    result.success = self._handler.getCampaigns(args.campaignName)
+    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_deleteCampaign(self, seqid, iprot, oprot):
+    args = deleteCampaign_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteCampaign_result()
+    self._handler.deleteCampaign(args.campaignId)
+    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getAllCampaigns(self, seqid, iprot, oprot):
+    args = getAllCampaigns_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAllCampaigns_result()
+    result.success = self._handler.getAllCampaigns()
+    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_deleteSimilarItem(self, seqid, iprot, oprot):
     args = deleteSimilarItem_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = deleteSimilarItem_result()
     return not (self == other)
 class addBanner_args:
   """
   Attributes:
-   - bannerName
+   - banner
-   - imageName
-   - link
-   - priority
-   - isActive
-   - hasMap
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'bannerName', None, None, ), # 1
+    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
-    (2, TType.STRING, 'imageName', None, None, ), # 2
-    (3, TType.STRING, 'link', None, None, ), # 3
-    (4, TType.I64, 'priority', None, None, ), # 4
-    (5, TType.BOOL, 'isActive', None, None, ), # 5
-    (6, TType.BOOL, 'hasMap', None, None, ), # 6
+  )
-  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
-    self.bannerName = bannerName
+  def __init__(self, banner=None,):
-    self.imageName = imageName
-    self.link = link
-    self.priority = priority
-    self.isActive = isActive
-    self.hasMap = hasMap
+    self.banner = banner
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.STRING:
+        if ftype == TType.STRUCT:
-          self.bannerName = iprot.readString();
+          self.banner = Banner()
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.STRING:
-          self.imageName = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRING:
-          self.link = iprot.readString();
+          self.banner.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.I64:
-          self.priority = 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('addBanner_args')
+    if self.banner is not None:
+      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
+      self.banner.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class addBanner_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
-      elif fid == 5:
+      if fid == 0:
         if ftype == TType.BOOL:
-          self.isActive = iprot.readBool();
+          self.success = iprot.readBool();
         else:
           iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('addBanner_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateBanner_args:
+  """
+  Attributes:
+   - banner
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
+  )
+  def __init__(self, banner=None,):
+    self.banner = banner
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
-      elif fid == 6:
+      if fid == 1:
-        if ftype == TType.BOOL:
+        if ftype == TType.STRUCT:
+          self.banner = Banner()
-          self.hasMap = iprot.readBool();
+          self.banner.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('addBanner_args')
+    oprot.writeStructBegin('updateBanner_args')
-    if self.bannerName is not None:
+    if self.banner is not None:
-      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
+      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
-      oprot.writeString(self.bannerName)
-      oprot.writeFieldEnd()
-    if self.imageName is not None:
-      oprot.writeFieldBegin('imageName', TType.STRING, 2)
-      oprot.writeString(self.imageName)
-      oprot.writeFieldEnd()
-    if self.link is not None:
+      self.banner.write(oprot)
-      oprot.writeFieldBegin('link', TType.STRING, 3)
-      oprot.writeString(self.link)
-      oprot.writeFieldEnd()
-    if self.priority is not None:
-      oprot.writeFieldBegin('priority', TType.I64, 4)
-      oprot.writeI64(self.priority)
-      oprot.writeFieldEnd()
-    if self.isActive is not None:
-      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
-      oprot.writeBool(self.isActive)
-      oprot.writeFieldEnd()
-    if self.hasMap is not None:
-      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
-      oprot.writeBool(self.hasMap)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addBanner_result:
+class updateBanner_result:
   """
   Attributes:
    - success
   """
   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('addBanner_result')
+    oprot.writeStructBegin('updateBanner_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
   Attributes:
    - success
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
+  )
   def __init__(self, success=None,):
     self.success = success
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
           (_etype184, _size181) = iprot.readListBegin()
           for _i185 in xrange(_size181):
-            _elem186 = iprot.readString();
+            _elem186 = Banner()
+            _elem186.read(iprot)
             self.success.append(_elem186)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
     oprot.writeStructBegin('getAllBanners_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRING, len(self.success))
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
       for iter187 in self.success:
-        oprot.writeString(iter187)
+        iter187.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   Attributes:
    - success
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
+    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
+  )
   def __init__(self, success=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.LIST:
+        if ftype == TType.MAP:
-          self.success = []
+          self.success = {}
-          (_etype191, _size188) = iprot.readListBegin()
+          (_ktype189, _vtype190, _size188 ) = iprot.readMapBegin()
           for _i192 in xrange(_size188):
+            _key193 = iprot.readString();
+            _val194 = []
+            (_etype198, _size195) = iprot.readListBegin()
+            for _i199 in xrange(_size195):
-            _elem193 = Banner()
+              _elem200 = Banner()
-            _elem193.read(iprot)
+              _elem200.read(iprot)
-            self.success.append(_elem193)
+              _val194.append(_elem200)
-          iprot.readListEnd()
+            iprot.readListEnd()
+            self.success[_key193] = _val194
+          iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     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('getActiveBanners_result')
     if self.success is not None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeFieldBegin('success', TType.MAP, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
-      for iter194 in self.success:
+      for kiter201,viter202 in self.success.items():
+        oprot.writeString(kiter201)
+        oprot.writeListBegin(TType.STRUCT, len(viter202))
+        for iter203 in viter202:
-        iter194.write(oprot)
+          iter203.write(oprot)
-      oprot.writeListEnd()
+        oprot.writeListEnd()
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return not (self == other)
 class addBannerMap_args:
   """
   Attributes:
-   - bannerName
+   - bannerMaps
-   - mapLink
-   - coordinates
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'bannerName', None, None, ), # 1
+    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
-    (2, TType.STRING, 'mapLink', None, None, ), # 2
-    (3, TType.STRING, 'coordinates', None, None, ), # 3
+  )
-  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
+  def __init__(self, bannerMaps=None,):
-    self.bannerName = bannerName
+    self.bannerMaps = bannerMaps
-    self.mapLink = mapLink
-    self.coordinates = coordinates
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.STRING:
+        if ftype == TType.LIST:
+          self.bannerMaps = []
+          (_etype207, _size204) = iprot.readListBegin()
+          for _i208 in xrange(_size204):
+            _elem209 = BannerMap()
+            _elem209.read(iprot)
-          self.bannerName = iprot.readString();
+            self.bannerMaps.append(_elem209)
+          iprot.readListEnd()
         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('addBannerMap_args')
+    if self.bannerMaps is not None:
+      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
+      for iter210 in self.bannerMaps:
+        iter210.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class addBannerMap_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
-      elif fid == 2:
+      if fid == 0:
-        if ftype == TType.STRING:
+        if ftype == TType.BOOL:
-          self.mapLink = iprot.readString();
+          self.success = iprot.readBool();
         else:
           iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('addBannerMap_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateBannerMap_args:
+  """
+  Attributes:
+   - bannerMap
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
+  )
+  def __init__(self, bannerMap=None,):
+    self.bannerMap = bannerMap
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
-      elif fid == 3:
+      if fid == 1:
-        if ftype == TType.STRING:
+        if ftype == TType.STRUCT:
+          self.bannerMap = BannerMap()
-          self.coordinates = iprot.readString();
+          self.bannerMap.read(iprot)
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('addBannerMap_args')
+    oprot.writeStructBegin('updateBannerMap_args')
-    if self.bannerName is not None:
+    if self.bannerMap is not None:
-      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
+      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
-      oprot.writeString(self.bannerName)
-      oprot.writeFieldEnd()
-    if self.mapLink is not None:
-      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
-      oprot.writeString(self.mapLink)
-      oprot.writeFieldEnd()
-    if self.coordinates is not None:
+      self.bannerMap.write(oprot)
-      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
-      oprot.writeString(self.coordinates)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addBannerMap_result:
+class updateBannerMap_result:
   """
   Attributes:
    - success
   """
   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('addBannerMap_result')
+    oprot.writeStructBegin('updateBannerMap_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype198, _size195) = iprot.readListBegin()
+          (_etype214, _size211) = iprot.readListBegin()
-          for _i199 in xrange(_size195):
+          for _i215 in xrange(_size211):
-            _elem200 = BannerMap()
+            _elem216 = BannerMap()
-            _elem200.read(iprot)
+            _elem216.read(iprot)
-            self.success.append(_elem200)
+            self.success.append(_elem216)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getBannerMapDetails_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter217 in self.success:
+        iter217.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class addBannerUri_args:
+  """
+  Attributes:
+   - bannerUriMappings
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
+  )
+  def __init__(self, bannerUriMappings=None,):
+    self.bannerUriMappings = bannerUriMappings
+  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.LIST:
+          self.bannerUriMappings = []
+          (_etype221, _size218) = iprot.readListBegin()
+          for _i222 in xrange(_size218):
+            _elem223 = BannerUriMapping()
+            _elem223.read(iprot)
+            self.bannerUriMappings.append(_elem223)
+          iprot.readListEnd()
+        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('addBannerUri_args')
+    if self.bannerUriMappings is not None:
+      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
+      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
+      for iter224 in self.bannerUriMappings:
+        iter224.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class addBannerUri_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('addBannerUri_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getUriMapping_args:
+  """
+  Attributes:
+   - bannerName
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'bannerName', None, None, ), # 1
+  )
+  def __init__(self, bannerName=None,):
+    self.bannerName = bannerName
+  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.bannerName = 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('getUriMapping_args')
+    if self.bannerName is not None:
+      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
+      oprot.writeString(self.bannerName)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getUriMapping_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  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 = []
+          (_etype228, _size225) = iprot.readListBegin()
+          for _i229 in xrange(_size225):
+            _elem230 = BannerUriMapping()
+            _elem230.read(iprot)
+            self.success.append(_elem230)
+          iprot.readListEnd()
+        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('getUriMapping_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter201 in self.success:
+      for iter231 in self.success:
-        iter201.write(oprot)
+        iter231.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class addCampaign_args:
+  """
+  Attributes:
+   - campaign
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
+  )
+  def __init__(self, campaign=None,):
+    self.campaign = campaign
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.campaign = Campaign()
+          self.campaign.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('addCampaign_args')
+    if self.campaign is not None:
+      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
+      self.campaign.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class addCampaign_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('addCampaign_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCampaigns_args:
+  """
+  Attributes:
+   - campaignName
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRING, 'campaignName', None, None, ), # 1
+  )
+  def __init__(self, campaignName=None,):
+    self.campaignName = campaignName
+  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.campaignName = 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('getCampaigns_args')
+    if self.campaignName is not None:
+      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
+      oprot.writeString(self.campaignName)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getCampaigns_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  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 = []
+          (_etype235, _size232) = iprot.readListBegin()
+          for _i236 in xrange(_size232):
+            _elem237 = Campaign()
+            _elem237.read(iprot)
+            self.success.append(_elem237)
+          iprot.readListEnd()
+        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('getCampaigns_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter238 in self.success:
+        iter238.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class deleteCampaign_args:
+  """
+  Attributes:
+   - campaignId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'campaignId', None, None, ), # 1
+  )
+  def __init__(self, campaignId=None,):
+    self.campaignId = campaignId
+  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.campaignId = 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('deleteCampaign_args')
+    if self.campaignId is not None:
+      oprot.writeFieldBegin('campaignId', TType.I64, 1)
+      oprot.writeI64(self.campaignId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class deleteCampaign_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('deleteCampaign_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getAllCampaigns_args:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getAllCampaigns_args')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getAllCampaigns_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  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 = []
+          (_etype242, _size239) = iprot.readListBegin()
+          for _i243 in xrange(_size239):
+            _elem244 = iprot.readString();
+            self.success.append(_elem244)
+          iprot.readListEnd()
+        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('getAllCampaigns_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRING, len(self.success))
+      for iter245 in self.success:
+        oprot.writeString(iter245)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype205, _size202) = iprot.readListBegin()
+          (_etype249, _size246) = iprot.readListBegin()
-          for _i206 in xrange(_size202):
+          for _i250 in xrange(_size246):
-            _elem207 = Item()
+            _elem251 = Item()
-            _elem207.read(iprot)
+            _elem251.read(iprot)
-            self.success.append(_elem207)
+            self.success.append(_elem251)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getItemsByRiskyFlag_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter208 in self.success:
+      for iter252 in self.success:
-        iter208.write(oprot)
+        iter252.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype212, _size209) = iprot.readListBegin()
+          (_etype256, _size253) = iprot.readListBegin()
-          for _i213 in xrange(_size209):
+          for _i257 in xrange(_size253):
-            _elem214 = Item()
+            _elem258 = Item()
-            _elem214.read(iprot)
+            _elem258.read(iprot)
-            self.success.append(_elem214)
+            self.success.append(_elem258)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getItemsForMasterSheet_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter215 in self.success:
+      for iter259 in self.success:
-        iter215.write(oprot)
+        iter259.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype219, _size216) = iprot.readListBegin()
+          (_etype263, _size260) = iprot.readListBegin()
-          for _i220 in xrange(_size216):
+          for _i264 in xrange(_size260):
-            _elem221 = iprot.readI64();
+            _elem265 = iprot.readI64();
-            self.success.append(_elem221)
+            self.success.append(_elem265)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter222 in self.success:
+      for iter266 in self.success:
-        oprot.writeI64(iter222)
+        oprot.writeI64(iter266)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype226, _size223) = iprot.readListBegin()
+          (_etype270, _size267) = iprot.readListBegin()
-          for _i227 in xrange(_size223):
+          for _i271 in xrange(_size267):
-            _elem228 = iprot.readString();
+            _elem272 = iprot.readString();
-            self.success.append(_elem228)
+            self.success.append(_elem272)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllBrandsByCategory_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter229 in self.success:
+      for iter273 in self.success:
-        oprot.writeString(iter229)
+        oprot.writeString(iter273)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype233, _size230) = iprot.readListBegin()
+          (_etype277, _size274) = iprot.readListBegin()
-          for _i234 in xrange(_size230):
+          for _i278 in xrange(_size274):
-            _elem235 = iprot.readString();
+            _elem279 = iprot.readString();
-            self.success.append(_elem235)
+            self.success.append(_elem279)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllBrands_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter236 in self.success:
+      for iter280 in self.success:
-        oprot.writeString(iter236)
+        oprot.writeString(iter280)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype240, _size237) = iprot.readListBegin()
+          (_etype284, _size281) = iprot.readListBegin()
-          for _i241 in xrange(_size237):
+          for _i285 in xrange(_size281):
-            _elem242 = Source()
+            _elem286 = Source()
-            _elem242.read(iprot)
+            _elem286.read(iprot)
-            self.success.append(_elem242)
+            self.success.append(_elem286)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllSources_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter243 in self.success:
+      for iter287 in self.success:
-        iter243.write(oprot)
+        iter287.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype247, _size244) = iprot.readListBegin()
+          (_etype291, _size288) = iprot.readListBegin()
-          for _i248 in xrange(_size244):
+          for _i292 in xrange(_size288):
-            _elem249 = SourceItemPricing()
+            _elem293 = SourceItemPricing()
-            _elem249.read(iprot)
+            _elem293.read(iprot)
-            self.success.append(_elem249)
+            self.success.append(_elem293)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllSourcePricing_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter250 in self.success:
+      for iter294 in self.success:
-        iter250.write(oprot)
+        iter294.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.cex is not None:
       oprot.writeFieldBegin('cex', TType.STRUCT, 1)
       self.cex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.searchTerms = []
-          (_etype254, _size251) = iprot.readListBegin()
+          (_etype298, _size295) = iprot.readListBegin()
-          for _i255 in xrange(_size251):
+          for _i299 in xrange(_size295):
-            _elem256 = iprot.readString();
+            _elem300 = iprot.readString();
-            self.searchTerms.append(_elem256)
+            self.searchTerms.append(_elem300)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('searchItemsInRange_args')
     if self.searchTerms is not None:
       oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
       oprot.writeListBegin(TType.STRING, len(self.searchTerms))
-      for iter257 in self.searchTerms:
+      for iter301 in self.searchTerms:
-        oprot.writeString(iter257)
+        oprot.writeString(iter301)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.offset is not None:
       oprot.writeFieldBegin('offset', TType.I64, 2)
       oprot.writeI64(self.offset)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype261, _size258) = iprot.readListBegin()
+          (_etype305, _size302) = iprot.readListBegin()
-          for _i262 in xrange(_size258):
+          for _i306 in xrange(_size302):
-            _elem263 = Item()
+            _elem307 = Item()
-            _elem263.read(iprot)
+            _elem307.read(iprot)
-            self.success.append(_elem263)
+            self.success.append(_elem307)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('searchItemsInRange_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter264 in self.success:
+      for iter308 in self.success:
-        iter264.write(oprot)
+        iter308.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.searchTerms = []
-          (_etype268, _size265) = iprot.readListBegin()
+          (_etype312, _size309) = iprot.readListBegin()
-          for _i269 in xrange(_size265):
+          for _i313 in xrange(_size309):
-            _elem270 = iprot.readString();
+            _elem314 = iprot.readString();
-            self.searchTerms.append(_elem270)
+            self.searchTerms.append(_elem314)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getSearchResultCount_args')
     if self.searchTerms is not None:
       oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
       oprot.writeListBegin(TType.STRING, len(self.searchTerms))
-      for iter271 in self.searchTerms:
+      for iter315 in self.searchTerms:
-        oprot.writeString(iter271)
+        oprot.writeString(iter315)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype275, _size272) = iprot.readListBegin()
+          (_etype319, _size316) = iprot.readListBegin()
-          for _i276 in xrange(_size272):
+          for _i320 in xrange(_size316):
-            _elem277 = ProductNotificationRequest()
+            _elem321 = ProductNotificationRequest()
-            _elem277.read(iprot)
+            _elem321.read(iprot)
-            self.success.append(_elem277)
+            self.success.append(_elem321)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getProductNotifications_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter278 in self.success:
+      for iter322 in self.success:
-        iter278.write(oprot)
+        iter322.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype282, _size279) = iprot.readListBegin()
+          (_etype326, _size323) = iprot.readListBegin()
-          for _i283 in xrange(_size279):
+          for _i327 in xrange(_size323):
-            _elem284 = ProductNotificationRequestCount()
+            _elem328 = ProductNotificationRequestCount()
-            _elem284.read(iprot)
+            _elem328.read(iprot)
-            self.success.append(_elem284)
+            self.success.append(_elem328)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getProductNotificationRequestCount_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter285 in self.success:
+      for iter329 in self.success:
-        iter285.write(oprot)
+        iter329.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype289, _size286) = iprot.readListBegin()
+          (_etype333, _size330) = iprot.readListBegin()
-          for _i290 in xrange(_size286):
+          for _i334 in xrange(_size330):
-            _elem291 = VoucherItemMapping()
+            _elem335 = VoucherItemMapping()
-            _elem291.read(iprot)
+            _elem335.read(iprot)
-            self.success.append(_elem291)
+            self.success.append(_elem335)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllItemVouchers_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter292 in self.success:
+      for iter336 in self.success:
-        iter292.write(oprot)
+        iter336.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype296, _size293) = iprot.readListBegin()
+          (_etype340, _size337) = iprot.readListBegin()
-          for _i297 in xrange(_size293):
+          for _i341 in xrange(_size337):
-            _elem298 = Item()
+            _elem342 = Item()
-            _elem298.read(iprot)
+            _elem342.read(iprot)
-            self.success.append(_elem298)
+            self.success.append(_elem342)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter299 in self.success:
+      for iter343 in self.success:
-        iter299.write(oprot)
+        iter343.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype303, _size300) = iprot.readListBegin()
+          (_etype347, _size344) = iprot.readListBegin()
-          for _i304 in xrange(_size300):
+          for _i348 in xrange(_size344):
-            _elem305 = Item()
+            _elem349 = Item()
-            _elem305.read(iprot)
+            _elem349.read(iprot)
-            self.success.append(_elem305)
+            self.success.append(_elem349)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllAliveItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter306 in self.success:
+      for iter350 in self.success:
-        iter306.write(oprot)
+        iter350.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype310, _size307) = iprot.readListBegin()
+          (_etype354, _size351) = iprot.readListBegin()
-          for _i311 in xrange(_size307):
+          for _i355 in xrange(_size351):
-            _elem312 = Insurer()
+            _elem356 = Insurer()
-            _elem312.read(iprot)
+            _elem356.read(iprot)
-            self.success.append(_elem312)
+            self.success.append(_elem356)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllInsurers_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter313 in self.success:
+      for iter357 in self.success:
-        iter313.write(oprot)
+        iter357.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
+          (_ktype359, _vtype360, _size358 ) = iprot.readMapBegin()
-          for _i318 in xrange(_size314):
+          for _i362 in xrange(_size358):
-            _key319 = iprot.readString();
+            _key363 = iprot.readString();
-            _val320 = BrandInfo()
+            _val364 = BrandInfo()
-            _val320.read(iprot)
+            _val364.read(iprot)
-            self.success[_key319] = _val320
+            self.success[_key363] = _val364
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getBrandInfo_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
-      for kiter321,viter322 in self.success.items():
+      for kiter365,viter366 in self.success.items():
-        oprot.writeString(kiter321)
+        oprot.writeString(kiter365)
-        viter322.write(oprot)
+        viter366.write(oprot)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.itemIds = []
-          (_etype326, _size323) = iprot.readListBegin()
+          (_etype370, _size367) = iprot.readListBegin()
-          for _i327 in xrange(_size323):
+          for _i371 in xrange(_size367):
-            _elem328 = iprot.readI64();
+            _elem372 = iprot.readI64();
-            self.itemIds.append(_elem328)
+            self.itemIds.append(_elem372)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getStorePricings_args')
     if self.itemIds is not None:
       oprot.writeFieldBegin('itemIds', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.itemIds))
-      for iter329 in self.itemIds:
+      for iter373 in self.itemIds:
-        oprot.writeI64(iter329)
+        oprot.writeI64(iter373)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype333, _size330) = iprot.readListBegin()
+          (_etype377, _size374) = iprot.readListBegin()
-          for _i334 in xrange(_size330):
+          for _i378 in xrange(_size374):
-            _elem335 = StorePricing()
+            _elem379 = StorePricing()
-            _elem335.read(iprot)
+            _elem379.read(iprot)
-            self.success.append(_elem335)
+            self.success.append(_elem379)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getStorePricings_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter336 in self.success:
+      for iter380 in self.success:
-        iter336.write(oprot)
+        iter380.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype340, _size337) = iprot.readListBegin()
+          (_etype384, _size381) = iprot.readListBegin()
-          for _i341 in xrange(_size337):
+          for _i385 in xrange(_size381):
-            _elem342 = Amazonlisted()
+            _elem386 = Amazonlisted()
-            _elem342.read(iprot)
+            _elem386.read(iprot)
-            self.success.append(_elem342)
+            self.success.append(_elem386)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllAmazonListedItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter343 in self.success:
+      for iter387 in self.success:
-        iter343.write(oprot)
+        iter387.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype347, _size344) = iprot.readListBegin()
+          (_etype391, _size388) = iprot.readListBegin()
-          for _i348 in xrange(_size344):
+          for _i392 in xrange(_size388):
-            _elem349 = Item()
+            _elem393 = Item()
-            _elem349.read(iprot)
+            _elem393.read(iprot)
-            self.success.append(_elem349)
+            self.success.append(_elem393)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAsinItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter350 in self.success:
+      for iter394 in self.success:
-        iter350.write(oprot)
+        iter394.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype354, _size351) = iprot.readListBegin()
+          (_etype398, _size395) = iprot.readListBegin()
-          for _i355 in xrange(_size351):
+          for _i399 in xrange(_size395):
-            _elem356 = Amazonlisted()
+            _elem400 = Amazonlisted()
-            _elem356.read(iprot)
+            _elem400.read(iprot)
-            self.success.append(_elem356)
+            self.success.append(_elem400)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllFbaListedItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter357 in self.success:
+      for iter401 in self.success:
-        iter357.write(oprot)
+        iter401.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype361, _size358) = iprot.readListBegin()
+          (_etype405, _size402) = iprot.readListBegin()
-          for _i362 in xrange(_size358):
+          for _i406 in xrange(_size402):
-            _elem363 = Amazonlisted()
+            _elem407 = Amazonlisted()
-            _elem363.read(iprot)
+            _elem407.read(iprot)
-            self.success.append(_elem363)
+            self.success.append(_elem407)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllNonFbaListedItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter364 in self.success:
+      for iter408 in self.success:
-        iter364.write(oprot)
+        iter408.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.LIST:
           self.sku = []
-          (_etype368, _size365) = iprot.readListBegin()
+          (_etype412, _size409) = iprot.readListBegin()
-          for _i369 in xrange(_size365):
+          for _i413 in xrange(_size409):
-            _elem370 = iprot.readI64();
+            _elem414 = iprot.readI64();
-            self.sku.append(_elem370)
+            self.sku.append(_elem414)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.I64:
       oprot.writeString(self.type)
       oprot.writeFieldEnd()
     if self.sku is not None:
       oprot.writeFieldBegin('sku', TType.LIST, 2)
       oprot.writeListBegin(TType.I64, len(self.sku))
-      for iter371 in self.sku:
+      for iter415 in self.sku:
-        oprot.writeI64(iter371)
+        oprot.writeI64(iter415)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.timestamp is not None:
       oprot.writeFieldBegin('timestamp', TType.I64, 3)
       oprot.writeI64(self.timestamp)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype375, _size372) = iprot.readListBegin()
+          (_etype419, _size416) = iprot.readListBegin()
-          for _i376 in xrange(_size372):
+          for _i420 in xrange(_size416):
-            _elem377 = Category()
+            _elem421 = Category()
-            _elem377.read(iprot)
+            _elem421.read(iprot)
-            self.success.append(_elem377)
+            self.success.append(_elem421)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllParentCategories_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter378 in self.success:
+      for iter422 in self.success:
-        iter378.write(oprot)
+        iter422.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype382, _size379) = iprot.readListBegin()
+          (_etype426, _size423) = iprot.readListBegin()
-          for _i383 in xrange(_size379):
+          for _i427 in xrange(_size423):
-            _elem384 = Amazonlisted()
+            _elem428 = Amazonlisted()
-            _elem384.read(iprot)
+            _elem428.read(iprot)
-            self.success.append(_elem384)
+            self.success.append(_elem428)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAmazonListedItems_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter385 in self.success:
+      for iter429 in self.success:
-        iter385.write(oprot)
+        iter429.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.amazonlisted = {}
-          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
+          (_ktype431, _vtype432, _size430 ) = iprot.readMapBegin()
-          for _i390 in xrange(_size386):
+          for _i434 in xrange(_size430):
-            _key391 = iprot.readI64();
+            _key435 = iprot.readI64();
-            _val392 = Amazonlisted()
+            _val436 = Amazonlisted()
-            _val392.read(iprot)
+            _val436.read(iprot)
-            self.amazonlisted[_key391] = _val392
+            self.amazonlisted[_key435] = _val436
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
     if self.amazonlisted is not None:
       oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
-      for kiter393,viter394 in self.amazonlisted.items():
+      for kiter437,viter438 in self.amazonlisted.items():
-        oprot.writeI64(kiter393)
+        oprot.writeI64(kiter437)
-        viter394.write(oprot)
+        viter438.write(oprot)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype398, _size395) = iprot.readListBegin()
+          (_etype442, _size439) = iprot.readListBegin()
-          for _i399 in xrange(_size395):
+          for _i443 in xrange(_size439):
-            _elem400 = Amazonlisted()
+            _elem444 = Amazonlisted()
-            _elem400.read(iprot)
+            _elem444.read(iprot)
-            self.success.append(_elem400)
+            self.success.append(_elem444)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllItemstoListOnFba_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter401 in self.success:
+      for iter445 in self.success:
-        iter401.write(oprot)
+        iter445.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype405, _size402) = iprot.readListBegin()
+          (_etype449, _size446) = iprot.readListBegin()
-          for _i406 in xrange(_size402):
+          for _i450 in xrange(_size446):
-            _elem407 = Amazonlisted()
+            _elem451 = Amazonlisted()
-            _elem407.read(iprot)
+            _elem451.read(iprot)
-            self.success.append(_elem407)
+            self.success.append(_elem451)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter408 in self.success:
+      for iter452 in self.success:
-        iter408.write(oprot)
+        iter452.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/thriftpy/model/v1/catalog/CatalogService.py – Rev 8379 → 8579