Subversion Repositories SmartDukaan

Rev

Rev 7306 | Rev 7340 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
46 
  def getItemStatusDescription(self, itemId):
47 
    """
48 
    Parameters:
49 
     - itemId
50 
    """
51 
    pass
52 
 
53 
  def startItemOn(self, item_id, timestamp):
54 
    """
55 
    Parameters:
56 
     - item_id
57 
     - timestamp
58 
    """
59 
    pass
60 
 
61 
  def retireItemOn(self, item_id, timestamp):
62 
    """
63 
    Parameters:
64 
     - item_id
65 
     - timestamp
66 
    """
67 
    pass
68 
 
69 
  def changeItemStatus(self, item_id, timestamp, newstatus):
70 
    """
71 
    Parameters:
72 
     - item_id
73 
     - timestamp
74 
     - newstatus
75 
    """
76 
    pass
77 
 
78 
  def getItem(self, item_id):
79 
    """
80 
    Parameters:
81 
     - item_id
82 
    """
83 
    pass
84 
 
85 
  def getItemsByCatalogId(self, catalog_item_id):
86 
    """
87 
    Parameters:
88 
     - catalog_item_id
89 
    """
90 
    pass
91 
 
92 
  def getValidItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getAllItems(self, isActive):
100 
    """
101 
    Parameters:
102 
     - isActive
103 
    """
104 
    pass
105 
 
106 
  def getAllItemsByStatus(self, itemStatus):
107 
    """
108 
    Parameters:
109 
     - itemStatus
110 
    """
111 
    pass
112 
 
113 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
114 
    """
115 
    Parameters:
116 
     - entityId
117 
     - category
118 
     - brand
119 
     - modelName
120 
     - modelNumber
121 
    """
122 
    pass
123 
 
124 
  def getAllItemsInRange(self, offset, limit):
125 
    """
126 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
127 
 
128 
    Parameters:
129 
     - offset
130 
     - limit
131 
    """
132 
    pass
133 
 
134 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
135 
    """
136 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
137 
 
138 
    Parameters:
139 
     - itemStatus
140 
     - offset
141 
     - limit
142 
    """
143 
    pass
144 
 
145 
  def getItemCountByStatus(self, useStatus, itemStatus):
146 
    """
147 
    Gets a count of all items by status
148 
 
149 
    Parameters:
150 
     - useStatus
151 
     - itemStatus
152 
    """
153 
    pass
154 
 
155 
  def getBestSellers(self, ):
156 
    pass
157 
 
158 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
159 
    """
160 
    Parameters:
161 
     - beginIndex
162 
     - totalItems
163 
     - brand
164 
     - category
165 
    """
166 
    pass
167 
 
168 
  def getBestSellersCount(self, ):
169 
    pass
170 
 
171 
  def getBestDeals(self, ):
172 
    pass
173 
 
174 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
175 
    """
176 
    Parameters:
177 
     - beginIndex
178 
     - totalItems
179 
     - brand
180 
     - category
181 
    """
182 
    pass
183 
 
184 
  def getBestDealsCount(self, ):
185 
    pass
186 
 
187 
  def getComingSoon(self, ):
188 
    pass
189 
 
190 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
191 
    """
192 
    Parameters:
193 
     - beginIndex
194 
     - totalItems
195 
     - brand
196 
     - category
197 
    """
198 
    pass
199 
 
200 
  def getComingSoonCount(self, ):
201 
    pass
202 
 
203 
  def getLatestArrivals(self, ):
204 
    """
205 
    Returns a list of items sorted in the descending order by start date.
206 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
207 
    """
208 
    pass
209 
 
210 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
211 
    """
212 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
213 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
214 
 
215 
    Parameters:
216 
     - beginIndex
217 
     - totalItems
218 
     - brand
219 
     - categories
220 
    """
221 
    pass
222 
 
223 
  def getLatestArrivalsCount(self, ):
224 
    """
225 
    Get the total number of latest arrivals we are willing to show.
226 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
227 
    """
228 
    pass
229 
 
230 
  def generateNewEntityID(self, ):
231 
    pass
232 
 
233 
  def addCategory(self, category):
234 
    """
235 
    All category related functions
236 
 
237 
    Parameters:
238 
     - category
239 
    """
240 
    pass
241 
 
242 
  def getCategory(self, id):
243 
    """
244 
    Parameters:
245 
     - id
246 
    """
247 
    pass
248 
 
249 
  def getAllCategories(self, ):
250 
    pass
251 
 
252 
  def getAllSimilarItems(self, itemId):
253 
    """
254 
    Returns the list of similar items.
255 
 
256 
    Parameters:
257 
     - itemId
258 
    """
259 
    pass
260 
 
261 
  def addSimilarItem(self, itemId, catalogItemId):
262 
    """
263 
    Adds similar item.
264 
 
265 
    Parameters:
266 
     - itemId
267 
     - catalogItemId
268 
    """
269 
    pass
270 
 
6512 kshitij.so 271 
  def addTag(self, displayName, itemId):
272 
    """
273 
    Tag Related
274 
 
275 
    Parameters:
276 
     - displayName
277 
     - itemId
278 
    """
279 
    pass
280 
 
281 
  def deleteEntityTag(self, displayName, itemId):
282 
    """
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteTag(self, displayName):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
    """
294 
    pass
295 
 
296 
  def getAllTags(self, ):
297 
    pass
298 
 
299 
  def getAllEntitiesByTagName(self, displayName):
300 
    """
301 
    Parameters:
302 
     - displayName
303 
    """
304 
    pass
305 
 
6845 amit.gupta 306 
  def getAllEntityTags(self, ):
307 
    pass
308 
 
6850 kshitij.so 309 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
310 
    """
311 
    Parameters:
312 
     - bannerName
313 
     - imageName
314 
     - link
315 
     - priority
316 
     - isActive
317 
     - hasMap
318 
    """
319 
    pass
320 
 
321 
  def getAllBanners(self, ):
322 
    pass
323 
 
324 
  def deleteBanner(self, bannerName):
325 
    """
326 
    Parameters:
327 
     - bannerName
328 
    """
329 
    pass
330 
 
331 
  def getBannerDetails(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getActiveBanners(self, ):
339 
    pass
340 
 
6849 kshitij.so 341 
  def addBannerMap(self, bannerName, mapLink, coordinates):
342 
    """
343 
    Parameters:
344 
     - bannerName
345 
     - mapLink
346 
     - coordinates
347 
    """
348 
    pass
349 
 
350 
  def deleteBannerMap(self, bannerName):
351 
    """
352 
    Parameters:
353 
     - bannerName
354 
    """
355 
    pass
356 
 
357 
  def getBannerMapDetails(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
5944 mandeep.dh 364 
  def deleteSimilarItem(self, itemId, catalogItemId):
365 
    """
366 
    Delete similar item.
367 
 
368 
    Parameters:
369 
     - itemId
370 
     - catalogItemId
371 
    """
372 
    pass
373 
 
374 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
375 
    """
376 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
377 
    If yes, returns the itemId else returns 0
378 
 
379 
    Parameters:
380 
     - brand
381 
     - modelNumber
382 
     - modelName
383 
     - color
384 
    """
385 
    pass
386 
 
387 
  def validateRiskyStatus(self, itemId):
388 
    """
389 
    Check wether item is risky and change status if inventory is not available for risky items
390 
 
391 
    Parameters:
392 
     - itemId
393 
    """
394 
    pass
395 
 
396 
  def changeItemRiskyFlag(self, itemId, risky):
397 
    """
398 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
399 
 
400 
    Parameters:
401 
     - itemId
402 
     - risky
403 
    """
404 
    pass
405 
 
406 
  def getItemsByRiskyFlag(self, ):
407 
    """
408 
    Returns list of items marked as risky.
409 
    """
410 
    pass
411 
 
412 
  def getItemsForMasterSheet(self, category, brand):
413 
    """
414 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
415 
 
416 
    Parameters:
417 
     - category
418 
     - brand
419 
    """
420 
    pass
421 
 
422 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
423 
    """
424 
    Returns list of catalog ids of items with same similarity index as of the given itemId
425 
 
426 
    Parameters:
427 
     - beginIndex
428 
     - totalItems
429 
     - itemId
430 
    """
431 
    pass
432 
 
433 
  def addProductNotification(self, itemId, email):
434 
    """
435 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
436 
 
437 
    Parameters:
438 
     - itemId
439 
     - email
440 
    """
441 
    pass
442 
 
443 
  def sendProductNotifications(self, ):
444 
    """
445 
    Send the product notifications to the users for items which has stock.
446 
    """
447 
    pass
448 
 
449 
  def getAllBrandsByCategory(self, categoryId):
450 
    """
451 
    Returns list of brand names for a given category Id
452 
 
453 
    Parameters:
454 
     - categoryId
455 
    """
456 
    pass
457 
 
458 
  def getAllBrands(self, ):
459 
    """
460 
    Returns list of brand names
461 
    """
462 
    pass
463 
 
464 
  def getAllSources(self, ):
465 
    """
466 
    Return list of all sources
467 
    """
468 
    pass
469 
 
470 
  def getItemPricingBySource(self, itemId, sourceId):
471 
    """
472 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
473 
 
474 
    Parameters:
475 
     - itemId
476 
     - sourceId
477 
    """
478 
    pass
479 
 
480 
  def addSourceItemPricing(self, sourceItemPricing):
481 
    """
482 
    Adds prices to be displayed corresponding to the item if user comes from a source.
483 
    If item is not found or source is not found, it will throw exception.
484 
 
485 
    Parameters:
486 
     - sourceItemPricing
487 
    """
488 
    pass
489 
 
490 
  def getAllSourcePricing(self, itemId):
491 
    """
492 
    Returns the list of source pricing information of an item.
493 
    Raises an exception if item not found corresponding to itemId
494 
 
495 
    Parameters:
496 
     - itemId
497 
    """
498 
    pass
499 
 
500 
  def getItemForSource(self, item_id, sourceId):
501 
    """
502 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
503 
 
504 
    Parameters:
505 
     - item_id
506 
     - sourceId
507 
    """
508 
    pass
509 
 
510 
  def searchItemsInRange(self, searchTerms, offset, limit):
511 
    """
512 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
513 
 
514 
    Parameters:
515 
     - searchTerms
516 
     - offset
517 
     - limit
518 
    """
519 
    pass
520 
 
521 
  def getSearchResultCount(self, searchTerms):
522 
    """
523 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
524 
 
525 
    Parameters:
526 
     - searchTerms
527 
    """
528 
    pass
529 
 
530 
  def getProductNotifications(self, startDateTime):
531 
    """
532 
    Returns a list of product notifications added after a supplied datetime
533 
 
534 
    Parameters:
535 
     - startDateTime
536 
    """
537 
    pass
538 
 
539 
  def getProductNotificationRequestCount(self, startDateTime):
540 
    """
541 
    Returns a list of count of requests for product notification against each item
542 
 
543 
    Parameters:
544 
     - startDateTime
545 
    """
546 
    pass
547 
 
548 
  def addAuthorizationLog(self, itemId, username, reason):
549 
    """
550 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
551 
 
552 
    Parameters:
553 
     - itemId
554 
     - username
555 
     - reason
556 
    """
557 
    pass
558 
 
559 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
560 
    """
561 
    Parameters:
562 
     - catalog_item_id
563 
     - voucherType
564 
     - voucherAmount
565 
    """
566 
    pass
567 
 
568 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
569 
    """
570 
    Parameters:
571 
     - catalog_item_id
572 
     - voucherType
573 
    """
574 
    pass
575 
 
576 
  def getVoucherAmount(self, itemId, voucherType):
577 
    """
578 
    Parameters:
579 
     - itemId
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getAllItemVouchers(self, itemId):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
    """
589 
    pass
590 
 
591 
  def isValidCatalogItemId(self, catalog_item_id):
592 
    """
593 
    Parameters:
594 
     - catalog_item_id
595 
    """
596 
    pass
597 
 
7330 amit.gupta 598 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 599 
    """
600 
    Parameters:
601 
     - itemId
7330 amit.gupta 602 
     - stateId
6039 amit.gupta 603 
     - price
604 
    """
605 
    pass
5944 mandeep.dh 606 
 
6039 amit.gupta 607 
  def getVatAmountForItem(self, itemId, price):
608 
    """
609 
    Parameters:
610 
     - itemId
611 
     - price
612 
    """
613 
    pass
614 
 
6531 vikram.rag 615 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
616 
    """
617 
    Parameters:
618 
     - offset
619 
     - limit
620 
    """
621 
    pass
6039 amit.gupta 622 
 
6821 amar.kumar 623 
  def getAllAliveItems(self, ):
624 
    pass
625 
 
6921 anupam.sin 626 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 627 
    """
628 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 629 
 
6805 anupam.sin 630 
    Parameters:
631 
     - itemId
6921 anupam.sin 632 
     - price
6805 anupam.sin 633 
     - insurerId
634 
     - quantity
635 
    """
636 
    pass
637 
 
638 
  def getInsurer(self, insurerId):
639 
    """
640 
    Parameters:
641 
     - insurerId
642 
    """
643 
    pass
644 
 
6838 vikram.rag 645 
  def getAllInsurers(self, ):
646 
    pass
6805 anupam.sin 647 
 
6962 rajveer 648 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
649 
    """
650 
    Parameters:
651 
     - insurerId
652 
     - amount
653 
    """
654 
    pass
6838 vikram.rag 655 
 
7190 amar.kumar 656 
  def getFreebieForItem(self, itemId):
657 
    """
658 
    Parameters:
659 
     - itemId
660 
    """
661 
    pass
6962 rajveer 662 
 
7190 amar.kumar 663 
  def addOrUpdateFreebieForItem(self, freebieItem):
664 
    """
665 
    Parameters:
666 
     - freebieItem
667 
    """
668 
    pass
669 
 
7272 amit.gupta 670 
  def addOrUpdateBrandInfo(self, brandInfo):
671 
    """
672 
    Parameters:
673 
     - brandInfo
674 
    """
675 
    pass
676 
 
677 
  def getBrandInfo(self, ):
678 
    pass
679 
 
7256 rajveer 680 
  def getStorePricing(self, itemId):
681 
    """
682 
    Parameters:
683 
     - itemId
684 
    """
685 
    pass
7190 amar.kumar 686 
 
7306 rajveer 687 
  def getStorePricings(self, itemIds):
688 
    """
689 
    Parameters:
690 
     - itemIds
691 
    """
692 
    pass
693 
 
7265 rajveer 694 
  def updateStorePricing(self, sp):
695 
    """
696 
    Parameters:
697 
     - sp
698 
    """
699 
    pass
7256 rajveer 700 
 
7281 kshitij.so 701 
  def getAllAmazonListedItems(self, ):
702 
    pass
7265 rajveer 703 
 
7281 kshitij.so 704 
  def getAmazonItemDetails(self, itemId):
705 
    """
706 
    Parameters:
707 
     - itemId
708 
    """
709 
    pass
710 
 
711 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
712 
    """
713 
    Parameters:
714 
     - itemId
715 
     - fbaPrice
716 
     - sellingPrice
717 
     - isFba
718 
     - isNonFba
719 
     - isInventoryOverride
720 
    """
721 
    pass
722 
 
723 
  def addAmazonItem(self, amazonlisted):
724 
    """
725 
    Parameters:
726 
     - amazonlisted
727 
    """
728 
    pass
729 
 
7291 vikram.rag 730 
  def getAsinItems(self, ):
731 
    pass
7281 kshitij.so 732 
 
7291 vikram.rag 733 
  def getAllFbaListedItems(self, ):
734 
    pass
735 
 
736 
  def getAllNonFbaListedItems(self, ):
737 
    pass
738 
 
739 
 
5944 mandeep.dh 740 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
741 
  def __init__(self, iprot, oprot=None):
742 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
743 
 
744 
  def addItem(self, item):
745 
    """
746 
    Availability and inventory attributes
747 
 
748 
    Parameters:
749 
     - item
750 
    """
751 
    self.send_addItem(item)
752 
    return self.recv_addItem()
753 
 
754 
  def send_addItem(self, item):
755 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
756 
    args = addItem_args()
757 
    args.item = item
758 
    args.write(self._oprot)
759 
    self._oprot.writeMessageEnd()
760 
    self._oprot.trans.flush()
761 
 
762 
  def recv_addItem(self, ):
763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
764 
    if mtype == TMessageType.EXCEPTION:
765 
      x = TApplicationException()
766 
      x.read(self._iprot)
767 
      self._iprot.readMessageEnd()
768 
      raise x
769 
    result = addItem_result()
770 
    result.read(self._iprot)
771 
    self._iprot.readMessageEnd()
772 
    if result.success is not None:
773 
      return result.success
774 
    if result.cex is not None:
775 
      raise result.cex
776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
777 
 
778 
  def updateItem(self, item):
779 
    """
780 
    Parameters:
781 
     - item
782 
    """
783 
    self.send_updateItem(item)
784 
    return self.recv_updateItem()
785 
 
786 
  def send_updateItem(self, item):
787 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
788 
    args = updateItem_args()
789 
    args.item = item
790 
    args.write(self._oprot)
791 
    self._oprot.writeMessageEnd()
792 
    self._oprot.trans.flush()
793 
 
794 
  def recv_updateItem(self, ):
795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
796 
    if mtype == TMessageType.EXCEPTION:
797 
      x = TApplicationException()
798 
      x.read(self._iprot)
799 
      self._iprot.readMessageEnd()
800 
      raise x
801 
    result = updateItem_result()
802 
    result.read(self._iprot)
803 
    self._iprot.readMessageEnd()
804 
    if result.success is not None:
805 
      return result.success
806 
    if result.cex is not None:
807 
      raise result.cex
808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
809 
 
810 
  def isActive(self, itemId):
811 
    """
812 
    Checks if the item given to the corresponding itemId is active. If it's active,
813 
    whether it's risky and if it's risky, its inventory position.
814 
 
815 
    Parameters:
816 
     - itemId
817 
    """
818 
    self.send_isActive(itemId)
819 
    return self.recv_isActive()
820 
 
821 
  def send_isActive(self, itemId):
822 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
823 
    args = isActive_args()
824 
    args.itemId = itemId
825 
    args.write(self._oprot)
826 
    self._oprot.writeMessageEnd()
827 
    self._oprot.trans.flush()
828 
 
829 
  def recv_isActive(self, ):
830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
831 
    if mtype == TMessageType.EXCEPTION:
832 
      x = TApplicationException()
833 
      x.read(self._iprot)
834 
      self._iprot.readMessageEnd()
835 
      raise x
836 
    result = isActive_result()
837 
    result.read(self._iprot)
838 
    self._iprot.readMessageEnd()
839 
    if result.success is not None:
840 
      return result.success
841 
    if result.isex is not None:
842 
      raise result.isex
843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
844 
 
845 
  def getItemStatusDescription(self, itemId):
846 
    """
847 
    Parameters:
848 
     - itemId
849 
    """
850 
    self.send_getItemStatusDescription(itemId)
851 
    return self.recv_getItemStatusDescription()
852 
 
853 
  def send_getItemStatusDescription(self, itemId):
854 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
855 
    args = getItemStatusDescription_args()
856 
    args.itemId = itemId
857 
    args.write(self._oprot)
858 
    self._oprot.writeMessageEnd()
859 
    self._oprot.trans.flush()
860 
 
861 
  def recv_getItemStatusDescription(self, ):
862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
863 
    if mtype == TMessageType.EXCEPTION:
864 
      x = TApplicationException()
865 
      x.read(self._iprot)
866 
      self._iprot.readMessageEnd()
867 
      raise x
868 
    result = getItemStatusDescription_result()
869 
    result.read(self._iprot)
870 
    self._iprot.readMessageEnd()
871 
    if result.success is not None:
872 
      return result.success
873 
    if result.isex is not None:
874 
      raise result.isex
875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
876 
 
877 
  def startItemOn(self, item_id, timestamp):
878 
    """
879 
    Parameters:
880 
     - item_id
881 
     - timestamp
882 
    """
883 
    self.send_startItemOn(item_id, timestamp)
884 
    self.recv_startItemOn()
885 
 
886 
  def send_startItemOn(self, item_id, timestamp):
887 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
888 
    args = startItemOn_args()
889 
    args.item_id = item_id
890 
    args.timestamp = timestamp
891 
    args.write(self._oprot)
892 
    self._oprot.writeMessageEnd()
893 
    self._oprot.trans.flush()
894 
 
895 
  def recv_startItemOn(self, ):
896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
897 
    if mtype == TMessageType.EXCEPTION:
898 
      x = TApplicationException()
899 
      x.read(self._iprot)
900 
      self._iprot.readMessageEnd()
901 
      raise x
902 
    result = startItemOn_result()
903 
    result.read(self._iprot)
904 
    self._iprot.readMessageEnd()
905 
    if result.cex is not None:
906 
      raise result.cex
907 
    return
908 
 
909 
  def retireItemOn(self, item_id, timestamp):
910 
    """
911 
    Parameters:
912 
     - item_id
913 
     - timestamp
914 
    """
915 
    self.send_retireItemOn(item_id, timestamp)
916 
    self.recv_retireItemOn()
917 
 
918 
  def send_retireItemOn(self, item_id, timestamp):
919 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
920 
    args = retireItemOn_args()
921 
    args.item_id = item_id
922 
    args.timestamp = timestamp
923 
    args.write(self._oprot)
924 
    self._oprot.writeMessageEnd()
925 
    self._oprot.trans.flush()
926 
 
927 
  def recv_retireItemOn(self, ):
928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
929 
    if mtype == TMessageType.EXCEPTION:
930 
      x = TApplicationException()
931 
      x.read(self._iprot)
932 
      self._iprot.readMessageEnd()
933 
      raise x
934 
    result = retireItemOn_result()
935 
    result.read(self._iprot)
936 
    self._iprot.readMessageEnd()
937 
    if result.cex is not None:
938 
      raise result.cex
939 
    return
940 
 
941 
  def changeItemStatus(self, item_id, timestamp, newstatus):
942 
    """
943 
    Parameters:
944 
     - item_id
945 
     - timestamp
946 
     - newstatus
947 
    """
948 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
949 
    self.recv_changeItemStatus()
950 
 
951 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
952 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
953 
    args = changeItemStatus_args()
954 
    args.item_id = item_id
955 
    args.timestamp = timestamp
956 
    args.newstatus = newstatus
957 
    args.write(self._oprot)
958 
    self._oprot.writeMessageEnd()
959 
    self._oprot.trans.flush()
960 
 
961 
  def recv_changeItemStatus(self, ):
962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
963 
    if mtype == TMessageType.EXCEPTION:
964 
      x = TApplicationException()
965 
      x.read(self._iprot)
966 
      self._iprot.readMessageEnd()
967 
      raise x
968 
    result = changeItemStatus_result()
969 
    result.read(self._iprot)
970 
    self._iprot.readMessageEnd()
971 
    if result.cex is not None:
972 
      raise result.cex
973 
    return
974 
 
975 
  def getItem(self, item_id):
976 
    """
977 
    Parameters:
978 
     - item_id
979 
    """
980 
    self.send_getItem(item_id)
981 
    return self.recv_getItem()
982 
 
983 
  def send_getItem(self, item_id):
984 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
985 
    args = getItem_args()
986 
    args.item_id = item_id
987 
    args.write(self._oprot)
988 
    self._oprot.writeMessageEnd()
989 
    self._oprot.trans.flush()
990 
 
991 
  def recv_getItem(self, ):
992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
993 
    if mtype == TMessageType.EXCEPTION:
994 
      x = TApplicationException()
995 
      x.read(self._iprot)
996 
      self._iprot.readMessageEnd()
997 
      raise x
998 
    result = getItem_result()
999 
    result.read(self._iprot)
1000 
    self._iprot.readMessageEnd()
1001 
    if result.success is not None:
1002 
      return result.success
1003 
    if result.cex is not None:
1004 
      raise result.cex
1005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1006 
 
1007 
  def getItemsByCatalogId(self, catalog_item_id):
1008 
    """
1009 
    Parameters:
1010 
     - catalog_item_id
1011 
    """
1012 
    self.send_getItemsByCatalogId(catalog_item_id)
1013 
    return self.recv_getItemsByCatalogId()
1014 
 
1015 
  def send_getItemsByCatalogId(self, catalog_item_id):
1016 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1017 
    args = getItemsByCatalogId_args()
1018 
    args.catalog_item_id = catalog_item_id
1019 
    args.write(self._oprot)
1020 
    self._oprot.writeMessageEnd()
1021 
    self._oprot.trans.flush()
1022 
 
1023 
  def recv_getItemsByCatalogId(self, ):
1024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1025 
    if mtype == TMessageType.EXCEPTION:
1026 
      x = TApplicationException()
1027 
      x.read(self._iprot)
1028 
      self._iprot.readMessageEnd()
1029 
      raise x
1030 
    result = getItemsByCatalogId_result()
1031 
    result.read(self._iprot)
1032 
    self._iprot.readMessageEnd()
1033 
    if result.success is not None:
1034 
      return result.success
1035 
    if result.cex is not None:
1036 
      raise result.cex
1037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1038 
 
1039 
  def getValidItemsByCatalogId(self, catalog_item_id):
1040 
    """
1041 
    Parameters:
1042 
     - catalog_item_id
1043 
    """
1044 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1045 
    return self.recv_getValidItemsByCatalogId()
1046 
 
1047 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1048 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1049 
    args = getValidItemsByCatalogId_args()
1050 
    args.catalog_item_id = catalog_item_id
1051 
    args.write(self._oprot)
1052 
    self._oprot.writeMessageEnd()
1053 
    self._oprot.trans.flush()
1054 
 
1055 
  def recv_getValidItemsByCatalogId(self, ):
1056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1057 
    if mtype == TMessageType.EXCEPTION:
1058 
      x = TApplicationException()
1059 
      x.read(self._iprot)
1060 
      self._iprot.readMessageEnd()
1061 
      raise x
1062 
    result = getValidItemsByCatalogId_result()
1063 
    result.read(self._iprot)
1064 
    self._iprot.readMessageEnd()
1065 
    if result.success is not None:
1066 
      return result.success
1067 
    if result.cex is not None:
1068 
      raise result.cex
1069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1070 
 
1071 
  def getAllItems(self, isActive):
1072 
    """
1073 
    Parameters:
1074 
     - isActive
1075 
    """
1076 
    self.send_getAllItems(isActive)
1077 
    return self.recv_getAllItems()
1078 
 
1079 
  def send_getAllItems(self, isActive):
1080 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1081 
    args = getAllItems_args()
1082 
    args.isActive = isActive
1083 
    args.write(self._oprot)
1084 
    self._oprot.writeMessageEnd()
1085 
    self._oprot.trans.flush()
1086 
 
1087 
  def recv_getAllItems(self, ):
1088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1089 
    if mtype == TMessageType.EXCEPTION:
1090 
      x = TApplicationException()
1091 
      x.read(self._iprot)
1092 
      self._iprot.readMessageEnd()
1093 
      raise x
1094 
    result = getAllItems_result()
1095 
    result.read(self._iprot)
1096 
    self._iprot.readMessageEnd()
1097 
    if result.success is not None:
1098 
      return result.success
1099 
    if result.cex is not None:
1100 
      raise result.cex
1101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1102 
 
1103 
  def getAllItemsByStatus(self, itemStatus):
1104 
    """
1105 
    Parameters:
1106 
     - itemStatus
1107 
    """
1108 
    self.send_getAllItemsByStatus(itemStatus)
1109 
    return self.recv_getAllItemsByStatus()
1110 
 
1111 
  def send_getAllItemsByStatus(self, itemStatus):
1112 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1113 
    args = getAllItemsByStatus_args()
1114 
    args.itemStatus = itemStatus
1115 
    args.write(self._oprot)
1116 
    self._oprot.writeMessageEnd()
1117 
    self._oprot.trans.flush()
1118 
 
1119 
  def recv_getAllItemsByStatus(self, ):
1120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1121 
    if mtype == TMessageType.EXCEPTION:
1122 
      x = TApplicationException()
1123 
      x.read(self._iprot)
1124 
      self._iprot.readMessageEnd()
1125 
      raise x
1126 
    result = getAllItemsByStatus_result()
1127 
    result.read(self._iprot)
1128 
    self._iprot.readMessageEnd()
1129 
    if result.success is not None:
1130 
      return result.success
1131 
    if result.cex is not None:
1132 
      raise result.cex
1133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1134 
 
1135 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1136 
    """
1137 
    Parameters:
1138 
     - entityId
1139 
     - category
1140 
     - brand
1141 
     - modelName
1142 
     - modelNumber
1143 
    """
1144 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1145 
    return self.recv_markItemAsContentComplete()
1146 
 
1147 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1148 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1149 
    args = markItemAsContentComplete_args()
1150 
    args.entityId = entityId
1151 
    args.category = category
1152 
    args.brand = brand
1153 
    args.modelName = modelName
1154 
    args.modelNumber = modelNumber
1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
1159 
  def recv_markItemAsContentComplete(self, ):
1160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1161 
    if mtype == TMessageType.EXCEPTION:
1162 
      x = TApplicationException()
1163 
      x.read(self._iprot)
1164 
      self._iprot.readMessageEnd()
1165 
      raise x
1166 
    result = markItemAsContentComplete_result()
1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
1169 
    if result.success is not None:
1170 
      return result.success
1171 
    if result.cex is not None:
1172 
      raise result.cex
1173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1174 
 
1175 
  def getAllItemsInRange(self, offset, limit):
1176 
    """
1177 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1178 
 
1179 
    Parameters:
1180 
     - offset
1181 
     - limit
1182 
    """
1183 
    self.send_getAllItemsInRange(offset, limit)
1184 
    return self.recv_getAllItemsInRange()
1185 
 
1186 
  def send_getAllItemsInRange(self, offset, limit):
1187 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1188 
    args = getAllItemsInRange_args()
1189 
    args.offset = offset
1190 
    args.limit = limit
1191 
    args.write(self._oprot)
1192 
    self._oprot.writeMessageEnd()
1193 
    self._oprot.trans.flush()
1194 
 
1195 
  def recv_getAllItemsInRange(self, ):
1196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1197 
    if mtype == TMessageType.EXCEPTION:
1198 
      x = TApplicationException()
1199 
      x.read(self._iprot)
1200 
      self._iprot.readMessageEnd()
1201 
      raise x
1202 
    result = getAllItemsInRange_result()
1203 
    result.read(self._iprot)
1204 
    self._iprot.readMessageEnd()
1205 
    if result.success is not None:
1206 
      return result.success
1207 
    if result.cex is not None:
1208 
      raise result.cex
1209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1210 
 
1211 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1212 
    """
1213 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
1214 
 
1215 
    Parameters:
1216 
     - itemStatus
1217 
     - offset
1218 
     - limit
1219 
    """
1220 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1221 
    return self.recv_getAllItemsByStatusInRange()
1222 
 
1223 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1224 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1225 
    args = getAllItemsByStatusInRange_args()
1226 
    args.itemStatus = itemStatus
1227 
    args.offset = offset
1228 
    args.limit = limit
1229 
    args.write(self._oprot)
1230 
    self._oprot.writeMessageEnd()
1231 
    self._oprot.trans.flush()
1232 
 
1233 
  def recv_getAllItemsByStatusInRange(self, ):
1234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1235 
    if mtype == TMessageType.EXCEPTION:
1236 
      x = TApplicationException()
1237 
      x.read(self._iprot)
1238 
      self._iprot.readMessageEnd()
1239 
      raise x
1240 
    result = getAllItemsByStatusInRange_result()
1241 
    result.read(self._iprot)
1242 
    self._iprot.readMessageEnd()
1243 
    if result.success is not None:
1244 
      return result.success
1245 
    if result.cex is not None:
1246 
      raise result.cex
1247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1248 
 
1249 
  def getItemCountByStatus(self, useStatus, itemStatus):
1250 
    """
1251 
    Gets a count of all items by status
1252 
 
1253 
    Parameters:
1254 
     - useStatus
1255 
     - itemStatus
1256 
    """
1257 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1258 
    return self.recv_getItemCountByStatus()
1259 
 
1260 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1261 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1262 
    args = getItemCountByStatus_args()
1263 
    args.useStatus = useStatus
1264 
    args.itemStatus = itemStatus
1265 
    args.write(self._oprot)
1266 
    self._oprot.writeMessageEnd()
1267 
    self._oprot.trans.flush()
1268 
 
1269 
  def recv_getItemCountByStatus(self, ):
1270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1271 
    if mtype == TMessageType.EXCEPTION:
1272 
      x = TApplicationException()
1273 
      x.read(self._iprot)
1274 
      self._iprot.readMessageEnd()
1275 
      raise x
1276 
    result = getItemCountByStatus_result()
1277 
    result.read(self._iprot)
1278 
    self._iprot.readMessageEnd()
1279 
    if result.success is not None:
1280 
      return result.success
1281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1282 
 
1283 
  def getBestSellers(self, ):
1284 
    self.send_getBestSellers()
1285 
    return self.recv_getBestSellers()
1286 
 
1287 
  def send_getBestSellers(self, ):
1288 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1289 
    args = getBestSellers_args()
1290 
    args.write(self._oprot)
1291 
    self._oprot.writeMessageEnd()
1292 
    self._oprot.trans.flush()
1293 
 
1294 
  def recv_getBestSellers(self, ):
1295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1296 
    if mtype == TMessageType.EXCEPTION:
1297 
      x = TApplicationException()
1298 
      x.read(self._iprot)
1299 
      self._iprot.readMessageEnd()
1300 
      raise x
1301 
    result = getBestSellers_result()
1302 
    result.read(self._iprot)
1303 
    self._iprot.readMessageEnd()
1304 
    if result.success is not None:
1305 
      return result.success
1306 
    if result.isex is not None:
1307 
      raise result.isex
1308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1309 
 
1310 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1311 
    """
1312 
    Parameters:
1313 
     - beginIndex
1314 
     - totalItems
1315 
     - brand
1316 
     - category
1317 
    """
1318 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1319 
    return self.recv_getBestSellersCatalogIds()
1320 
 
1321 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1322 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1323 
    args = getBestSellersCatalogIds_args()
1324 
    args.beginIndex = beginIndex
1325 
    args.totalItems = totalItems
1326 
    args.brand = brand
1327 
    args.category = category
1328 
    args.write(self._oprot)
1329 
    self._oprot.writeMessageEnd()
1330 
    self._oprot.trans.flush()
1331 
 
1332 
  def recv_getBestSellersCatalogIds(self, ):
1333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1334 
    if mtype == TMessageType.EXCEPTION:
1335 
      x = TApplicationException()
1336 
      x.read(self._iprot)
1337 
      self._iprot.readMessageEnd()
1338 
      raise x
1339 
    result = getBestSellersCatalogIds_result()
1340 
    result.read(self._iprot)
1341 
    self._iprot.readMessageEnd()
1342 
    if result.success is not None:
1343 
      return result.success
1344 
    if result.cex is not None:
1345 
      raise result.cex
1346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1347 
 
1348 
  def getBestSellersCount(self, ):
1349 
    self.send_getBestSellersCount()
1350 
    return self.recv_getBestSellersCount()
1351 
 
1352 
  def send_getBestSellersCount(self, ):
1353 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1354 
    args = getBestSellersCount_args()
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_getBestSellersCount(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = getBestSellersCount_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
1369 
    if result.success is not None:
1370 
      return result.success
1371 
    if result.cex is not None:
1372 
      raise result.cex
1373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1374 
 
1375 
  def getBestDeals(self, ):
1376 
    self.send_getBestDeals()
1377 
    return self.recv_getBestDeals()
1378 
 
1379 
  def send_getBestDeals(self, ):
1380 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1381 
    args = getBestDeals_args()
1382 
    args.write(self._oprot)
1383 
    self._oprot.writeMessageEnd()
1384 
    self._oprot.trans.flush()
1385 
 
1386 
  def recv_getBestDeals(self, ):
1387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1388 
    if mtype == TMessageType.EXCEPTION:
1389 
      x = TApplicationException()
1390 
      x.read(self._iprot)
1391 
      self._iprot.readMessageEnd()
1392 
      raise x
1393 
    result = getBestDeals_result()
1394 
    result.read(self._iprot)
1395 
    self._iprot.readMessageEnd()
1396 
    if result.success is not None:
1397 
      return result.success
1398 
    if result.isex is not None:
1399 
      raise result.isex
1400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1401 
 
1402 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1403 
    """
1404 
    Parameters:
1405 
     - beginIndex
1406 
     - totalItems
1407 
     - brand
1408 
     - category
1409 
    """
1410 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1411 
    return self.recv_getBestDealsCatalogIds()
1412 
 
1413 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1414 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1415 
    args = getBestDealsCatalogIds_args()
1416 
    args.beginIndex = beginIndex
1417 
    args.totalItems = totalItems
1418 
    args.brand = brand
1419 
    args.category = category
1420 
    args.write(self._oprot)
1421 
    self._oprot.writeMessageEnd()
1422 
    self._oprot.trans.flush()
1423 
 
1424 
  def recv_getBestDealsCatalogIds(self, ):
1425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1426 
    if mtype == TMessageType.EXCEPTION:
1427 
      x = TApplicationException()
1428 
      x.read(self._iprot)
1429 
      self._iprot.readMessageEnd()
1430 
      raise x
1431 
    result = getBestDealsCatalogIds_result()
1432 
    result.read(self._iprot)
1433 
    self._iprot.readMessageEnd()
1434 
    if result.success is not None:
1435 
      return result.success
1436 
    if result.cex is not None:
1437 
      raise result.cex
1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1439 
 
1440 
  def getBestDealsCount(self, ):
1441 
    self.send_getBestDealsCount()
1442 
    return self.recv_getBestDealsCount()
1443 
 
1444 
  def send_getBestDealsCount(self, ):
1445 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1446 
    args = getBestDealsCount_args()
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1451 
  def recv_getBestDealsCount(self, ):
1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1458 
    result = getBestDealsCount_result()
1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
1461 
    if result.success is not None:
1462 
      return result.success
1463 
    if result.cex is not None:
1464 
      raise result.cex
1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1466 
 
1467 
  def getComingSoon(self, ):
1468 
    self.send_getComingSoon()
1469 
    return self.recv_getComingSoon()
1470 
 
1471 
  def send_getComingSoon(self, ):
1472 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1473 
    args = getComingSoon_args()
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getComingSoon(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getComingSoon_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
1488 
    if result.success is not None:
1489 
      return result.success
1490 
    if result.isex is not None:
1491 
      raise result.isex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1493 
 
1494 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1495 
    """
1496 
    Parameters:
1497 
     - beginIndex
1498 
     - totalItems
1499 
     - brand
1500 
     - category
1501 
    """
1502 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1503 
    return self.recv_getComingSoonCatalogIds()
1504 
 
1505 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1506 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1507 
    args = getComingSoonCatalogIds_args()
1508 
    args.beginIndex = beginIndex
1509 
    args.totalItems = totalItems
1510 
    args.brand = brand
1511 
    args.category = category
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_getComingSoonCatalogIds(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = getComingSoonCatalogIds_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
1526 
    if result.success is not None:
1527 
      return result.success
1528 
    if result.cex is not None:
1529 
      raise result.cex
1530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1531 
 
1532 
  def getComingSoonCount(self, ):
1533 
    self.send_getComingSoonCount()
1534 
    return self.recv_getComingSoonCount()
1535 
 
1536 
  def send_getComingSoonCount(self, ):
1537 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1538 
    args = getComingSoonCount_args()
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_getComingSoonCount(self, ):
1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
1550 
    result = getComingSoonCount_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
1553 
    if result.success is not None:
1554 
      return result.success
1555 
    if result.cex is not None:
1556 
      raise result.cex
1557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1558 
 
1559 
  def getLatestArrivals(self, ):
1560 
    """
1561 
    Returns a list of items sorted in the descending order by start date.
1562 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1563 
    """
1564 
    self.send_getLatestArrivals()
1565 
    return self.recv_getLatestArrivals()
1566 
 
1567 
  def send_getLatestArrivals(self, ):
1568 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1569 
    args = getLatestArrivals_args()
1570 
    args.write(self._oprot)
1571 
    self._oprot.writeMessageEnd()
1572 
    self._oprot.trans.flush()
1573 
 
1574 
  def recv_getLatestArrivals(self, ):
1575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1576 
    if mtype == TMessageType.EXCEPTION:
1577 
      x = TApplicationException()
1578 
      x.read(self._iprot)
1579 
      self._iprot.readMessageEnd()
1580 
      raise x
1581 
    result = getLatestArrivals_result()
1582 
    result.read(self._iprot)
1583 
    self._iprot.readMessageEnd()
1584 
    if result.success is not None:
1585 
      return result.success
1586 
    if result.isex is not None:
1587 
      raise result.isex
1588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1589 
 
1590 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1591 
    """
1592 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1593 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1594 
 
1595 
    Parameters:
1596 
     - beginIndex
1597 
     - totalItems
1598 
     - brand
1599 
     - categories
1600 
    """
1601 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1602 
    return self.recv_getLatestArrivalsCatalogIds()
1603 
 
1604 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1605 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1606 
    args = getLatestArrivalsCatalogIds_args()
1607 
    args.beginIndex = beginIndex
1608 
    args.totalItems = totalItems
1609 
    args.brand = brand
1610 
    args.categories = categories
1611 
    args.write(self._oprot)
1612 
    self._oprot.writeMessageEnd()
1613 
    self._oprot.trans.flush()
1614 
 
1615 
  def recv_getLatestArrivalsCatalogIds(self, ):
1616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1617 
    if mtype == TMessageType.EXCEPTION:
1618 
      x = TApplicationException()
1619 
      x.read(self._iprot)
1620 
      self._iprot.readMessageEnd()
1621 
      raise x
1622 
    result = getLatestArrivalsCatalogIds_result()
1623 
    result.read(self._iprot)
1624 
    self._iprot.readMessageEnd()
1625 
    if result.success is not None:
1626 
      return result.success
1627 
    if result.cex is not None:
1628 
      raise result.cex
1629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1630 
 
1631 
  def getLatestArrivalsCount(self, ):
1632 
    """
1633 
    Get the total number of latest arrivals we are willing to show.
1634 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1635 
    """
1636 
    self.send_getLatestArrivalsCount()
1637 
    return self.recv_getLatestArrivalsCount()
1638 
 
1639 
  def send_getLatestArrivalsCount(self, ):
1640 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1641 
    args = getLatestArrivalsCount_args()
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1646 
  def recv_getLatestArrivalsCount(self, ):
1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1653 
    result = getLatestArrivalsCount_result()
1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
1656 
    if result.success is not None:
1657 
      return result.success
1658 
    if result.cex is not None:
1659 
      raise result.cex
1660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1661 
 
1662 
  def generateNewEntityID(self, ):
1663 
    self.send_generateNewEntityID()
1664 
    return self.recv_generateNewEntityID()
1665 
 
1666 
  def send_generateNewEntityID(self, ):
1667 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1668 
    args = generateNewEntityID_args()
1669 
    args.write(self._oprot)
1670 
    self._oprot.writeMessageEnd()
1671 
    self._oprot.trans.flush()
1672 
 
1673 
  def recv_generateNewEntityID(self, ):
1674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1675 
    if mtype == TMessageType.EXCEPTION:
1676 
      x = TApplicationException()
1677 
      x.read(self._iprot)
1678 
      self._iprot.readMessageEnd()
1679 
      raise x
1680 
    result = generateNewEntityID_result()
1681 
    result.read(self._iprot)
1682 
    self._iprot.readMessageEnd()
1683 
    if result.success is not None:
1684 
      return result.success
1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1686 
 
1687 
  def addCategory(self, category):
1688 
    """
1689 
    All category related functions
1690 
 
1691 
    Parameters:
1692 
     - category
1693 
    """
1694 
    self.send_addCategory(category)
1695 
    return self.recv_addCategory()
1696 
 
1697 
  def send_addCategory(self, category):
1698 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1699 
    args = addCategory_args()
1700 
    args.category = category
1701 
    args.write(self._oprot)
1702 
    self._oprot.writeMessageEnd()
1703 
    self._oprot.trans.flush()
1704 
 
1705 
  def recv_addCategory(self, ):
1706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1707 
    if mtype == TMessageType.EXCEPTION:
1708 
      x = TApplicationException()
1709 
      x.read(self._iprot)
1710 
      self._iprot.readMessageEnd()
1711 
      raise x
1712 
    result = addCategory_result()
1713 
    result.read(self._iprot)
1714 
    self._iprot.readMessageEnd()
1715 
    if result.success is not None:
1716 
      return result.success
1717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1718 
 
1719 
  def getCategory(self, id):
1720 
    """
1721 
    Parameters:
1722 
     - id
1723 
    """
1724 
    self.send_getCategory(id)
1725 
    return self.recv_getCategory()
1726 
 
1727 
  def send_getCategory(self, id):
1728 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1729 
    args = getCategory_args()
1730 
    args.id = id
1731 
    args.write(self._oprot)
1732 
    self._oprot.writeMessageEnd()
1733 
    self._oprot.trans.flush()
1734 
 
1735 
  def recv_getCategory(self, ):
1736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1737 
    if mtype == TMessageType.EXCEPTION:
1738 
      x = TApplicationException()
1739 
      x.read(self._iprot)
1740 
      self._iprot.readMessageEnd()
1741 
      raise x
1742 
    result = getCategory_result()
1743 
    result.read(self._iprot)
1744 
    self._iprot.readMessageEnd()
1745 
    if result.success is not None:
1746 
      return result.success
1747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1748 
 
1749 
  def getAllCategories(self, ):
1750 
    self.send_getAllCategories()
1751 
    return self.recv_getAllCategories()
1752 
 
1753 
  def send_getAllCategories(self, ):
1754 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1755 
    args = getAllCategories_args()
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getAllCategories(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getAllCategories_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
1770 
    if result.success is not None:
1771 
      return result.success
1772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1773 
 
1774 
  def getAllSimilarItems(self, itemId):
1775 
    """
1776 
    Returns the list of similar items.
1777 
 
1778 
    Parameters:
1779 
     - itemId
1780 
    """
1781 
    self.send_getAllSimilarItems(itemId)
1782 
    return self.recv_getAllSimilarItems()
1783 
 
1784 
  def send_getAllSimilarItems(self, itemId):
1785 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1786 
    args = getAllSimilarItems_args()
1787 
    args.itemId = itemId
1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
1792 
  def recv_getAllSimilarItems(self, ):
1793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1794 
    if mtype == TMessageType.EXCEPTION:
1795 
      x = TApplicationException()
1796 
      x.read(self._iprot)
1797 
      self._iprot.readMessageEnd()
1798 
      raise x
1799 
    result = getAllSimilarItems_result()
1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
1802 
    if result.success is not None:
1803 
      return result.success
1804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1805 
 
1806 
  def addSimilarItem(self, itemId, catalogItemId):
1807 
    """
1808 
    Adds similar item.
1809 
 
1810 
    Parameters:
1811 
     - itemId
1812 
     - catalogItemId
1813 
    """
1814 
    self.send_addSimilarItem(itemId, catalogItemId)
1815 
    return self.recv_addSimilarItem()
1816 
 
1817 
  def send_addSimilarItem(self, itemId, catalogItemId):
1818 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1819 
    args = addSimilarItem_args()
1820 
    args.itemId = itemId
1821 
    args.catalogItemId = catalogItemId
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_addSimilarItem(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = addSimilarItem_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    if result.success is not None:
1837 
      return result.success
1838 
    if result.cex is not None:
1839 
      raise result.cex
1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1841 
 
6512 kshitij.so 1842 
  def addTag(self, displayName, itemId):
1843 
    """
1844 
    Tag Related
1845 
 
1846 
    Parameters:
1847 
     - displayName
1848 
     - itemId
1849 
    """
1850 
    self.send_addTag(displayName, itemId)
1851 
    return self.recv_addTag()
1852 
 
1853 
  def send_addTag(self, displayName, itemId):
1854 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1855 
    args = addTag_args()
1856 
    args.displayName = displayName
1857 
    args.itemId = itemId
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_addTag(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = addTag_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
1872 
    if result.success is not None:
1873 
      return result.success
1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1875 
 
1876 
  def deleteEntityTag(self, displayName, itemId):
1877 
    """
1878 
    Parameters:
1879 
     - displayName
1880 
     - itemId
1881 
    """
1882 
    self.send_deleteEntityTag(displayName, itemId)
1883 
    return self.recv_deleteEntityTag()
1884 
 
1885 
  def send_deleteEntityTag(self, displayName, itemId):
1886 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1887 
    args = deleteEntityTag_args()
1888 
    args.displayName = displayName
1889 
    args.itemId = itemId
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_deleteEntityTag(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = deleteEntityTag_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
1904 
    if result.success is not None:
1905 
      return result.success
1906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1907 
 
1908 
  def deleteTag(self, displayName):
1909 
    """
1910 
    Parameters:
1911 
     - displayName
1912 
    """
1913 
    self.send_deleteTag(displayName)
1914 
    return self.recv_deleteTag()
1915 
 
1916 
  def send_deleteTag(self, displayName):
1917 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1918 
    args = deleteTag_args()
1919 
    args.displayName = displayName
1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_deleteTag(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = deleteTag_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
1934 
    if result.success is not None:
1935 
      return result.success
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1937 
 
1938 
  def getAllTags(self, ):
1939 
    self.send_getAllTags()
1940 
    return self.recv_getAllTags()
1941 
 
1942 
  def send_getAllTags(self, ):
1943 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1944 
    args = getAllTags_args()
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getAllTags(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getAllTags_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
1959 
    if result.success is not None:
1960 
      return result.success
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
1962 
 
1963 
  def getAllEntitiesByTagName(self, displayName):
1964 
    """
1965 
    Parameters:
1966 
     - displayName
1967 
    """
1968 
    self.send_getAllEntitiesByTagName(displayName)
1969 
    return self.recv_getAllEntitiesByTagName()
1970 
 
1971 
  def send_getAllEntitiesByTagName(self, displayName):
1972 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1973 
    args = getAllEntitiesByTagName_args()
1974 
    args.displayName = displayName
1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
1979 
  def recv_getAllEntitiesByTagName(self, ):
1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
1986 
    result = getAllEntitiesByTagName_result()
1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
1989 
    if result.success is not None:
1990 
      return result.success
1991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1992 
 
6845 amit.gupta 1993 
  def getAllEntityTags(self, ):
1994 
    self.send_getAllEntityTags()
1995 
    return self.recv_getAllEntityTags()
1996 
 
1997 
  def send_getAllEntityTags(self, ):
1998 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
1999 
    args = getAllEntityTags_args()
2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_getAllEntityTags(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = getAllEntityTags_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
2014 
    if result.success is not None:
2015 
      return result.success
2016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2017 
 
6850 kshitij.so 2018 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2019 
    """
2020 
    Parameters:
2021 
     - bannerName
2022 
     - imageName
2023 
     - link
2024 
     - priority
2025 
     - isActive
2026 
     - hasMap
2027 
    """
2028 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2029 
    return self.recv_addBanner()
2030 
 
2031 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2032 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2033 
    args = addBanner_args()
2034 
    args.bannerName = bannerName
2035 
    args.imageName = imageName
2036 
    args.link = link
2037 
    args.priority = priority
2038 
    args.isActive = isActive
2039 
    args.hasMap = hasMap
2040 
    args.write(self._oprot)
2041 
    self._oprot.writeMessageEnd()
2042 
    self._oprot.trans.flush()
2043 
 
2044 
  def recv_addBanner(self, ):
2045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2046 
    if mtype == TMessageType.EXCEPTION:
2047 
      x = TApplicationException()
2048 
      x.read(self._iprot)
2049 
      self._iprot.readMessageEnd()
2050 
      raise x
2051 
    result = addBanner_result()
2052 
    result.read(self._iprot)
2053 
    self._iprot.readMessageEnd()
2054 
    if result.success is not None:
2055 
      return result.success
2056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2057 
 
2058 
  def getAllBanners(self, ):
2059 
    self.send_getAllBanners()
2060 
    return self.recv_getAllBanners()
2061 
 
2062 
  def send_getAllBanners(self, ):
2063 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2064 
    args = getAllBanners_args()
2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
2069 
  def recv_getAllBanners(self, ):
2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
2076 
    result = getAllBanners_result()
2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
2079 
    if result.success is not None:
2080 
      return result.success
2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2082 
 
2083 
  def deleteBanner(self, bannerName):
2084 
    """
2085 
    Parameters:
2086 
     - bannerName
2087 
    """
2088 
    self.send_deleteBanner(bannerName)
2089 
    return self.recv_deleteBanner()
2090 
 
2091 
  def send_deleteBanner(self, bannerName):
2092 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2093 
    args = deleteBanner_args()
2094 
    args.bannerName = bannerName
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_deleteBanner(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = deleteBanner_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
2109 
    if result.success is not None:
2110 
      return result.success
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2112 
 
2113 
  def getBannerDetails(self, bannerName):
2114 
    """
2115 
    Parameters:
2116 
     - bannerName
2117 
    """
2118 
    self.send_getBannerDetails(bannerName)
2119 
    return self.recv_getBannerDetails()
2120 
 
2121 
  def send_getBannerDetails(self, bannerName):
2122 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2123 
    args = getBannerDetails_args()
2124 
    args.bannerName = bannerName
2125 
    args.write(self._oprot)
2126 
    self._oprot.writeMessageEnd()
2127 
    self._oprot.trans.flush()
2128 
 
2129 
  def recv_getBannerDetails(self, ):
2130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2131 
    if mtype == TMessageType.EXCEPTION:
2132 
      x = TApplicationException()
2133 
      x.read(self._iprot)
2134 
      self._iprot.readMessageEnd()
2135 
      raise x
2136 
    result = getBannerDetails_result()
2137 
    result.read(self._iprot)
2138 
    self._iprot.readMessageEnd()
2139 
    if result.success is not None:
2140 
      return result.success
2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2142 
 
2143 
  def getActiveBanners(self, ):
2144 
    self.send_getActiveBanners()
2145 
    return self.recv_getActiveBanners()
2146 
 
2147 
  def send_getActiveBanners(self, ):
2148 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2149 
    args = getActiveBanners_args()
2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
2154 
  def recv_getActiveBanners(self, ):
2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
2161 
    result = getActiveBanners_result()
2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
2164 
    if result.success is not None:
2165 
      return result.success
2166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2167 
 
6849 kshitij.so 2168 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2169 
    """
2170 
    Parameters:
2171 
     - bannerName
2172 
     - mapLink
2173 
     - coordinates
2174 
    """
2175 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2176 
    return self.recv_addBannerMap()
2177 
 
2178 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2179 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2180 
    args = addBannerMap_args()
2181 
    args.bannerName = bannerName
2182 
    args.mapLink = mapLink
2183 
    args.coordinates = coordinates
2184 
    args.write(self._oprot)
2185 
    self._oprot.writeMessageEnd()
2186 
    self._oprot.trans.flush()
2187 
 
2188 
  def recv_addBannerMap(self, ):
2189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2190 
    if mtype == TMessageType.EXCEPTION:
2191 
      x = TApplicationException()
2192 
      x.read(self._iprot)
2193 
      self._iprot.readMessageEnd()
2194 
      raise x
2195 
    result = addBannerMap_result()
2196 
    result.read(self._iprot)
2197 
    self._iprot.readMessageEnd()
2198 
    if result.success is not None:
2199 
      return result.success
2200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2201 
 
2202 
  def deleteBannerMap(self, bannerName):
2203 
    """
2204 
    Parameters:
2205 
     - bannerName
2206 
    """
2207 
    self.send_deleteBannerMap(bannerName)
2208 
    return self.recv_deleteBannerMap()
2209 
 
2210 
  def send_deleteBannerMap(self, bannerName):
2211 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2212 
    args = deleteBannerMap_args()
2213 
    args.bannerName = bannerName
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_deleteBannerMap(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = deleteBannerMap_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
2228 
    if result.success is not None:
2229 
      return result.success
2230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2231 
 
2232 
  def getBannerMapDetails(self, bannerName):
2233 
    """
2234 
    Parameters:
2235 
     - bannerName
2236 
    """
2237 
    self.send_getBannerMapDetails(bannerName)
2238 
    return self.recv_getBannerMapDetails()
2239 
 
2240 
  def send_getBannerMapDetails(self, bannerName):
2241 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2242 
    args = getBannerMapDetails_args()
2243 
    args.bannerName = bannerName
2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
2248 
  def recv_getBannerMapDetails(self, ):
2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
2255 
    result = getBannerMapDetails_result()
2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
2258 
    if result.success is not None:
2259 
      return result.success
2260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2261 
 
5944 mandeep.dh 2262 
  def deleteSimilarItem(self, itemId, catalogItemId):
2263 
    """
2264 
    Delete similar item.
2265 
 
2266 
    Parameters:
2267 
     - itemId
2268 
     - catalogItemId
2269 
    """
2270 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2271 
    return self.recv_deleteSimilarItem()
2272 
 
2273 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2274 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2275 
    args = deleteSimilarItem_args()
2276 
    args.itemId = itemId
2277 
    args.catalogItemId = catalogItemId
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_deleteSimilarItem(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = deleteSimilarItem_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
2292 
    if result.success is not None:
2293 
      return result.success
2294 
    if result.cex is not None:
2295 
      raise result.cex
2296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2297 
 
2298 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2299 
    """
2300 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2301 
    If yes, returns the itemId else returns 0
2302 
 
2303 
    Parameters:
2304 
     - brand
2305 
     - modelNumber
2306 
     - modelName
2307 
     - color
2308 
    """
2309 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2310 
    return self.recv_checkSimilarItem()
2311 
 
2312 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2313 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2314 
    args = checkSimilarItem_args()
2315 
    args.brand = brand
2316 
    args.modelNumber = modelNumber
2317 
    args.modelName = modelName
2318 
    args.color = color
2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
2323 
  def recv_checkSimilarItem(self, ):
2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
2330 
    result = checkSimilarItem_result()
2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
2333 
    if result.success is not None:
2334 
      return result.success
2335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2336 
 
2337 
  def validateRiskyStatus(self, itemId):
2338 
    """
2339 
    Check wether item is risky and change status if inventory is not available for risky items
2340 
 
2341 
    Parameters:
2342 
     - itemId
2343 
    """
2344 
    self.send_validateRiskyStatus(itemId)
2345 
    self.recv_validateRiskyStatus()
2346 
 
2347 
  def send_validateRiskyStatus(self, itemId):
2348 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2349 
    args = validateRiskyStatus_args()
2350 
    args.itemId = itemId
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_validateRiskyStatus(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = validateRiskyStatus_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    return
2366 
 
2367 
  def changeItemRiskyFlag(self, itemId, risky):
2368 
    """
2369 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2370 
 
2371 
    Parameters:
2372 
     - itemId
2373 
     - risky
2374 
    """
2375 
    self.send_changeItemRiskyFlag(itemId, risky)
2376 
    self.recv_changeItemRiskyFlag()
2377 
 
2378 
  def send_changeItemRiskyFlag(self, itemId, risky):
2379 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2380 
    args = changeItemRiskyFlag_args()
2381 
    args.itemId = itemId
2382 
    args.risky = risky
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_changeItemRiskyFlag(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = changeItemRiskyFlag_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
2397 
    return
2398 
 
2399 
  def getItemsByRiskyFlag(self, ):
2400 
    """
2401 
    Returns list of items marked as risky.
2402 
    """
2403 
    self.send_getItemsByRiskyFlag()
2404 
    return self.recv_getItemsByRiskyFlag()
2405 
 
2406 
  def send_getItemsByRiskyFlag(self, ):
2407 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2408 
    args = getItemsByRiskyFlag_args()
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_getItemsByRiskyFlag(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = getItemsByRiskyFlag_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
2423 
    if result.success is not None:
2424 
      return result.success
2425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2426 
 
2427 
  def getItemsForMasterSheet(self, category, brand):
2428 
    """
2429 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2430 
 
2431 
    Parameters:
2432 
     - category
2433 
     - brand
2434 
    """
2435 
    self.send_getItemsForMasterSheet(category, brand)
2436 
    return self.recv_getItemsForMasterSheet()
2437 
 
2438 
  def send_getItemsForMasterSheet(self, category, brand):
2439 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2440 
    args = getItemsForMasterSheet_args()
2441 
    args.category = category
2442 
    args.brand = brand
2443 
    args.write(self._oprot)
2444 
    self._oprot.writeMessageEnd()
2445 
    self._oprot.trans.flush()
2446 
 
2447 
  def recv_getItemsForMasterSheet(self, ):
2448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2449 
    if mtype == TMessageType.EXCEPTION:
2450 
      x = TApplicationException()
2451 
      x.read(self._iprot)
2452 
      self._iprot.readMessageEnd()
2453 
      raise x
2454 
    result = getItemsForMasterSheet_result()
2455 
    result.read(self._iprot)
2456 
    self._iprot.readMessageEnd()
2457 
    if result.success is not None:
2458 
      return result.success
2459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2460 
 
2461 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2462 
    """
2463 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2464 
 
2465 
    Parameters:
2466 
     - beginIndex
2467 
     - totalItems
2468 
     - itemId
2469 
    """
2470 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2471 
    return self.recv_getSimilarItemsCatalogIds()
2472 
 
2473 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2474 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2475 
    args = getSimilarItemsCatalogIds_args()
2476 
    args.beginIndex = beginIndex
2477 
    args.totalItems = totalItems
2478 
    args.itemId = itemId
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
2483 
  def recv_getSimilarItemsCatalogIds(self, ):
2484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2485 
    if mtype == TMessageType.EXCEPTION:
2486 
      x = TApplicationException()
2487 
      x.read(self._iprot)
2488 
      self._iprot.readMessageEnd()
2489 
      raise x
2490 
    result = getSimilarItemsCatalogIds_result()
2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
2493 
    if result.success is not None:
2494 
      return result.success
2495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2496 
 
2497 
  def addProductNotification(self, itemId, email):
2498 
    """
2499 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2500 
 
2501 
    Parameters:
2502 
     - itemId
2503 
     - email
2504 
    """
2505 
    self.send_addProductNotification(itemId, email)
2506 
    return self.recv_addProductNotification()
2507 
 
2508 
  def send_addProductNotification(self, itemId, email):
2509 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2510 
    args = addProductNotification_args()
2511 
    args.itemId = itemId
2512 
    args.email = email
2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
2517 
  def recv_addProductNotification(self, ):
2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
2524 
    result = addProductNotification_result()
2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
2527 
    if result.success is not None:
2528 
      return result.success
2529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2530 
 
2531 
  def sendProductNotifications(self, ):
2532 
    """
2533 
    Send the product notifications to the users for items which has stock.
2534 
    """
2535 
    self.send_sendProductNotifications()
2536 
    return self.recv_sendProductNotifications()
2537 
 
2538 
  def send_sendProductNotifications(self, ):
2539 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2540 
    args = sendProductNotifications_args()
2541 
    args.write(self._oprot)
2542 
    self._oprot.writeMessageEnd()
2543 
    self._oprot.trans.flush()
2544 
 
2545 
  def recv_sendProductNotifications(self, ):
2546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2547 
    if mtype == TMessageType.EXCEPTION:
2548 
      x = TApplicationException()
2549 
      x.read(self._iprot)
2550 
      self._iprot.readMessageEnd()
2551 
      raise x
2552 
    result = sendProductNotifications_result()
2553 
    result.read(self._iprot)
2554 
    self._iprot.readMessageEnd()
2555 
    if result.success is not None:
2556 
      return result.success
2557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2558 
 
2559 
  def getAllBrandsByCategory(self, categoryId):
2560 
    """
2561 
    Returns list of brand names for a given category Id
2562 
 
2563 
    Parameters:
2564 
     - categoryId
2565 
    """
2566 
    self.send_getAllBrandsByCategory(categoryId)
2567 
    return self.recv_getAllBrandsByCategory()
2568 
 
2569 
  def send_getAllBrandsByCategory(self, categoryId):
2570 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2571 
    args = getAllBrandsByCategory_args()
2572 
    args.categoryId = categoryId
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_getAllBrandsByCategory(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = getAllBrandsByCategory_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    if result.success is not None:
2588 
      return result.success
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2590 
 
2591 
  def getAllBrands(self, ):
2592 
    """
2593 
    Returns list of brand names
2594 
    """
2595 
    self.send_getAllBrands()
2596 
    return self.recv_getAllBrands()
2597 
 
2598 
  def send_getAllBrands(self, ):
2599 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2600 
    args = getAllBrands_args()
2601 
    args.write(self._oprot)
2602 
    self._oprot.writeMessageEnd()
2603 
    self._oprot.trans.flush()
2604 
 
2605 
  def recv_getAllBrands(self, ):
2606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2607 
    if mtype == TMessageType.EXCEPTION:
2608 
      x = TApplicationException()
2609 
      x.read(self._iprot)
2610 
      self._iprot.readMessageEnd()
2611 
      raise x
2612 
    result = getAllBrands_result()
2613 
    result.read(self._iprot)
2614 
    self._iprot.readMessageEnd()
2615 
    if result.success is not None:
2616 
      return result.success
2617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2618 
 
2619 
  def getAllSources(self, ):
2620 
    """
2621 
    Return list of all sources
2622 
    """
2623 
    self.send_getAllSources()
2624 
    return self.recv_getAllSources()
2625 
 
2626 
  def send_getAllSources(self, ):
2627 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2628 
    args = getAllSources_args()
2629 
    args.write(self._oprot)
2630 
    self._oprot.writeMessageEnd()
2631 
    self._oprot.trans.flush()
2632 
 
2633 
  def recv_getAllSources(self, ):
2634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2635 
    if mtype == TMessageType.EXCEPTION:
2636 
      x = TApplicationException()
2637 
      x.read(self._iprot)
2638 
      self._iprot.readMessageEnd()
2639 
      raise x
2640 
    result = getAllSources_result()
2641 
    result.read(self._iprot)
2642 
    self._iprot.readMessageEnd()
2643 
    if result.success is not None:
2644 
      return result.success
2645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2646 
 
2647 
  def getItemPricingBySource(self, itemId, sourceId):
2648 
    """
2649 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2650 
 
2651 
    Parameters:
2652 
     - itemId
2653 
     - sourceId
2654 
    """
2655 
    self.send_getItemPricingBySource(itemId, sourceId)
2656 
    return self.recv_getItemPricingBySource()
2657 
 
2658 
  def send_getItemPricingBySource(self, itemId, sourceId):
2659 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2660 
    args = getItemPricingBySource_args()
2661 
    args.itemId = itemId
2662 
    args.sourceId = sourceId
2663 
    args.write(self._oprot)
2664 
    self._oprot.writeMessageEnd()
2665 
    self._oprot.trans.flush()
2666 
 
2667 
  def recv_getItemPricingBySource(self, ):
2668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2669 
    if mtype == TMessageType.EXCEPTION:
2670 
      x = TApplicationException()
2671 
      x.read(self._iprot)
2672 
      self._iprot.readMessageEnd()
2673 
      raise x
2674 
    result = getItemPricingBySource_result()
2675 
    result.read(self._iprot)
2676 
    self._iprot.readMessageEnd()
2677 
    if result.success is not None:
2678 
      return result.success
2679 
    if result.cex is not None:
2680 
      raise result.cex
2681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2682 
 
2683 
  def addSourceItemPricing(self, sourceItemPricing):
2684 
    """
2685 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2686 
    If item is not found or source is not found, it will throw exception.
2687 
 
2688 
    Parameters:
2689 
     - sourceItemPricing
2690 
    """
2691 
    self.send_addSourceItemPricing(sourceItemPricing)
2692 
    self.recv_addSourceItemPricing()
2693 
 
2694 
  def send_addSourceItemPricing(self, sourceItemPricing):
2695 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2696 
    args = addSourceItemPricing_args()
2697 
    args.sourceItemPricing = sourceItemPricing
2698 
    args.write(self._oprot)
2699 
    self._oprot.writeMessageEnd()
2700 
    self._oprot.trans.flush()
2701 
 
2702 
  def recv_addSourceItemPricing(self, ):
2703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2704 
    if mtype == TMessageType.EXCEPTION:
2705 
      x = TApplicationException()
2706 
      x.read(self._iprot)
2707 
      self._iprot.readMessageEnd()
2708 
      raise x
2709 
    result = addSourceItemPricing_result()
2710 
    result.read(self._iprot)
2711 
    self._iprot.readMessageEnd()
2712 
    if result.cex is not None:
2713 
      raise result.cex
2714 
    return
2715 
 
2716 
  def getAllSourcePricing(self, itemId):
2717 
    """
2718 
    Returns the list of source pricing information of an item.
2719 
    Raises an exception if item not found corresponding to itemId
2720 
 
2721 
    Parameters:
2722 
     - itemId
2723 
    """
2724 
    self.send_getAllSourcePricing(itemId)
2725 
    return self.recv_getAllSourcePricing()
2726 
 
2727 
  def send_getAllSourcePricing(self, itemId):
2728 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2729 
    args = getAllSourcePricing_args()
2730 
    args.itemId = itemId
2731 
    args.write(self._oprot)
2732 
    self._oprot.writeMessageEnd()
2733 
    self._oprot.trans.flush()
2734 
 
2735 
  def recv_getAllSourcePricing(self, ):
2736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2737 
    if mtype == TMessageType.EXCEPTION:
2738 
      x = TApplicationException()
2739 
      x.read(self._iprot)
2740 
      self._iprot.readMessageEnd()
2741 
      raise x
2742 
    result = getAllSourcePricing_result()
2743 
    result.read(self._iprot)
2744 
    self._iprot.readMessageEnd()
2745 
    if result.success is not None:
2746 
      return result.success
2747 
    if result.cex is not None:
2748 
      raise result.cex
2749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2750 
 
2751 
  def getItemForSource(self, item_id, sourceId):
2752 
    """
2753 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2754 
 
2755 
    Parameters:
2756 
     - item_id
2757 
     - sourceId
2758 
    """
2759 
    self.send_getItemForSource(item_id, sourceId)
2760 
    return self.recv_getItemForSource()
2761 
 
2762 
  def send_getItemForSource(self, item_id, sourceId):
2763 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2764 
    args = getItemForSource_args()
2765 
    args.item_id = item_id
2766 
    args.sourceId = sourceId
2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_getItemForSource(self, ):
2772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2773 
    if mtype == TMessageType.EXCEPTION:
2774 
      x = TApplicationException()
2775 
      x.read(self._iprot)
2776 
      self._iprot.readMessageEnd()
2777 
      raise x
2778 
    result = getItemForSource_result()
2779 
    result.read(self._iprot)
2780 
    self._iprot.readMessageEnd()
2781 
    if result.success is not None:
2782 
      return result.success
2783 
    if result.cex is not None:
2784 
      raise result.cex
2785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2786 
 
2787 
  def searchItemsInRange(self, searchTerms, offset, limit):
2788 
    """
2789 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2790 
 
2791 
    Parameters:
2792 
     - searchTerms
2793 
     - offset
2794 
     - limit
2795 
    """
2796 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2797 
    return self.recv_searchItemsInRange()
2798 
 
2799 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2800 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2801 
    args = searchItemsInRange_args()
2802 
    args.searchTerms = searchTerms
2803 
    args.offset = offset
2804 
    args.limit = limit
2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
2809 
  def recv_searchItemsInRange(self, ):
2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
2816 
    result = searchItemsInRange_result()
2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
2819 
    if result.success is not None:
2820 
      return result.success
2821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2822 
 
2823 
  def getSearchResultCount(self, searchTerms):
2824 
    """
2825 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2826 
 
2827 
    Parameters:
2828 
     - searchTerms
2829 
    """
2830 
    self.send_getSearchResultCount(searchTerms)
2831 
    return self.recv_getSearchResultCount()
2832 
 
2833 
  def send_getSearchResultCount(self, searchTerms):
2834 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2835 
    args = getSearchResultCount_args()
2836 
    args.searchTerms = searchTerms
2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
2841 
  def recv_getSearchResultCount(self, ):
2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
2848 
    result = getSearchResultCount_result()
2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
2851 
    if result.success is not None:
2852 
      return result.success
2853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2854 
 
2855 
  def getProductNotifications(self, startDateTime):
2856 
    """
2857 
    Returns a list of product notifications added after a supplied datetime
2858 
 
2859 
    Parameters:
2860 
     - startDateTime
2861 
    """
2862 
    self.send_getProductNotifications(startDateTime)
2863 
    return self.recv_getProductNotifications()
2864 
 
2865 
  def send_getProductNotifications(self, startDateTime):
2866 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2867 
    args = getProductNotifications_args()
2868 
    args.startDateTime = startDateTime
2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
2873 
  def recv_getProductNotifications(self, ):
2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
2880 
    result = getProductNotifications_result()
2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
2883 
    if result.success is not None:
2884 
      return result.success
2885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2886 
 
2887 
  def getProductNotificationRequestCount(self, startDateTime):
2888 
    """
2889 
    Returns a list of count of requests for product notification against each item
2890 
 
2891 
    Parameters:
2892 
     - startDateTime
2893 
    """
2894 
    self.send_getProductNotificationRequestCount(startDateTime)
2895 
    return self.recv_getProductNotificationRequestCount()
2896 
 
2897 
  def send_getProductNotificationRequestCount(self, startDateTime):
2898 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2899 
    args = getProductNotificationRequestCount_args()
2900 
    args.startDateTime = startDateTime
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getProductNotificationRequestCount(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getProductNotificationRequestCount_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2918 
 
2919 
  def addAuthorizationLog(self, itemId, username, reason):
2920 
    """
2921 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2922 
 
2923 
    Parameters:
2924 
     - itemId
2925 
     - username
2926 
     - reason
2927 
    """
2928 
    self.send_addAuthorizationLog(itemId, username, reason)
2929 
    return self.recv_addAuthorizationLog()
2930 
 
2931 
  def send_addAuthorizationLog(self, itemId, username, reason):
2932 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2933 
    args = addAuthorizationLog_args()
2934 
    args.itemId = itemId
2935 
    args.username = username
2936 
    args.reason = reason
2937 
    args.write(self._oprot)
2938 
    self._oprot.writeMessageEnd()
2939 
    self._oprot.trans.flush()
2940 
 
2941 
  def recv_addAuthorizationLog(self, ):
2942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2943 
    if mtype == TMessageType.EXCEPTION:
2944 
      x = TApplicationException()
2945 
      x.read(self._iprot)
2946 
      self._iprot.readMessageEnd()
2947 
      raise x
2948 
    result = addAuthorizationLog_result()
2949 
    result.read(self._iprot)
2950 
    self._iprot.readMessageEnd()
2951 
    if result.success is not None:
2952 
      return result.success
2953 
    if result.cex is not None:
2954 
      raise result.cex
2955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2956 
 
2957 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2958 
    """
2959 
    Parameters:
2960 
     - catalog_item_id
2961 
     - voucherType
2962 
     - voucherAmount
2963 
    """
2964 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2965 
    return self.recv_addupdateVoucherForItem()
2966 
 
2967 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2968 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2969 
    args = addupdateVoucherForItem_args()
2970 
    args.catalog_item_id = catalog_item_id
2971 
    args.voucherType = voucherType
2972 
    args.voucherAmount = voucherAmount
2973 
    args.write(self._oprot)
2974 
    self._oprot.writeMessageEnd()
2975 
    self._oprot.trans.flush()
2976 
 
2977 
  def recv_addupdateVoucherForItem(self, ):
2978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2979 
    if mtype == TMessageType.EXCEPTION:
2980 
      x = TApplicationException()
2981 
      x.read(self._iprot)
2982 
      self._iprot.readMessageEnd()
2983 
      raise x
2984 
    result = addupdateVoucherForItem_result()
2985 
    result.read(self._iprot)
2986 
    self._iprot.readMessageEnd()
2987 
    if result.success is not None:
2988 
      return result.success
2989 
    if result.cex is not None:
2990 
      raise result.cex
2991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2992 
 
2993 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2994 
    """
2995 
    Parameters:
2996 
     - catalog_item_id
2997 
     - voucherType
2998 
    """
2999 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3000 
    return self.recv_deleteVoucherForItem()
3001 
 
3002 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3003 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3004 
    args = deleteVoucherForItem_args()
3005 
    args.catalog_item_id = catalog_item_id
3006 
    args.voucherType = voucherType
3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_deleteVoucherForItem(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = deleteVoucherForItem_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.success is not None:
3022 
      return result.success
3023 
    if result.cex is not None:
3024 
      raise result.cex
3025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3026 
 
3027 
  def getVoucherAmount(self, itemId, voucherType):
3028 
    """
3029 
    Parameters:
3030 
     - itemId
3031 
     - voucherType
3032 
    """
3033 
    self.send_getVoucherAmount(itemId, voucherType)
3034 
    return self.recv_getVoucherAmount()
3035 
 
3036 
  def send_getVoucherAmount(self, itemId, voucherType):
3037 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3038 
    args = getVoucherAmount_args()
3039 
    args.itemId = itemId
3040 
    args.voucherType = voucherType
3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
3045 
  def recv_getVoucherAmount(self, ):
3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
3052 
    result = getVoucherAmount_result()
3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3055 
    if result.success is not None:
3056 
      return result.success
3057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3058 
 
3059 
  def getAllItemVouchers(self, itemId):
3060 
    """
3061 
    Parameters:
3062 
     - itemId
3063 
    """
3064 
    self.send_getAllItemVouchers(itemId)
3065 
    return self.recv_getAllItemVouchers()
3066 
 
3067 
  def send_getAllItemVouchers(self, itemId):
3068 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3069 
    args = getAllItemVouchers_args()
3070 
    args.itemId = itemId
3071 
    args.write(self._oprot)
3072 
    self._oprot.writeMessageEnd()
3073 
    self._oprot.trans.flush()
3074 
 
3075 
  def recv_getAllItemVouchers(self, ):
3076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3077 
    if mtype == TMessageType.EXCEPTION:
3078 
      x = TApplicationException()
3079 
      x.read(self._iprot)
3080 
      self._iprot.readMessageEnd()
3081 
      raise x
3082 
    result = getAllItemVouchers_result()
3083 
    result.read(self._iprot)
3084 
    self._iprot.readMessageEnd()
3085 
    if result.success is not None:
3086 
      return result.success
3087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3088 
 
3089 
  def isValidCatalogItemId(self, catalog_item_id):
3090 
    """
3091 
    Parameters:
3092 
     - catalog_item_id
3093 
    """
3094 
    self.send_isValidCatalogItemId(catalog_item_id)
3095 
    return self.recv_isValidCatalogItemId()
3096 
 
3097 
  def send_isValidCatalogItemId(self, catalog_item_id):
3098 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3099 
    args = isValidCatalogItemId_args()
3100 
    args.catalog_item_id = catalog_item_id
3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_isValidCatalogItemId(self, ):
3106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3107 
    if mtype == TMessageType.EXCEPTION:
3108 
      x = TApplicationException()
3109 
      x.read(self._iprot)
3110 
      self._iprot.readMessageEnd()
3111 
      raise x
3112 
    result = isValidCatalogItemId_result()
3113 
    result.read(self._iprot)
3114 
    self._iprot.readMessageEnd()
3115 
    if result.success is not None:
3116 
      return result.success
3117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3118 
 
7330 amit.gupta 3119 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3120 
    """
3121 
    Parameters:
3122 
     - itemId
7330 amit.gupta 3123 
     - stateId
6039 amit.gupta 3124 
     - price
3125 
    """
7330 amit.gupta 3126 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3127 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3128 
 
7330 amit.gupta 3129 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3130 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3131 
    args = getVatPercentageForItem_args()
3132 
    args.itemId = itemId
7330 amit.gupta 3133 
    args.stateId = stateId
6039 amit.gupta 3134 
    args.price = price
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_getVatPercentageForItem(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = getVatPercentageForItem_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.success is not None:
3150 
      return result.success
3151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3152 
 
3153 
  def getVatAmountForItem(self, itemId, price):
3154 
    """
3155 
    Parameters:
3156 
     - itemId
3157 
     - price
3158 
    """
3159 
    self.send_getVatAmountForItem(itemId, price)
3160 
    return self.recv_getVatAmountForItem()
3161 
 
3162 
  def send_getVatAmountForItem(self, itemId, price):
3163 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3164 
    args = getVatAmountForItem_args()
3165 
    args.itemId = itemId
3166 
    args.price = price
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3171 
  def recv_getVatAmountForItem(self, ):
3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3178 
    result = getVatAmountForItem_result()
3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.success is not None:
3182 
      return result.success
3183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3184 
 
6531 vikram.rag 3185 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3186 
    """
3187 
    Parameters:
3188 
     - offset
3189 
     - limit
3190 
    """
3191 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3192 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3193 
 
6531 vikram.rag 3194 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3195 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3196 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3197 
    args.offset = offset
3198 
    args.limit = limit
3199 
    args.write(self._oprot)
3200 
    self._oprot.writeMessageEnd()
3201 
    self._oprot.trans.flush()
3202 
 
3203 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3205 
    if mtype == TMessageType.EXCEPTION:
3206 
      x = TApplicationException()
3207 
      x.read(self._iprot)
3208 
      self._iprot.readMessageEnd()
3209 
      raise x
3210 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3211 
    result.read(self._iprot)
3212 
    self._iprot.readMessageEnd()
3213 
    if result.success is not None:
3214 
      return result.success
3215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3216 
 
6821 amar.kumar 3217 
  def getAllAliveItems(self, ):
3218 
    self.send_getAllAliveItems()
3219 
    return self.recv_getAllAliveItems()
3220 
 
3221 
  def send_getAllAliveItems(self, ):
3222 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3223 
    args = getAllAliveItems_args()
3224 
    args.write(self._oprot)
3225 
    self._oprot.writeMessageEnd()
3226 
    self._oprot.trans.flush()
3227 
 
3228 
  def recv_getAllAliveItems(self, ):
3229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3230 
    if mtype == TMessageType.EXCEPTION:
3231 
      x = TApplicationException()
3232 
      x.read(self._iprot)
3233 
      self._iprot.readMessageEnd()
3234 
      raise x
3235 
    result = getAllAliveItems_result()
3236 
    result.read(self._iprot)
3237 
    self._iprot.readMessageEnd()
3238 
    if result.success is not None:
3239 
      return result.success
3240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3241 
 
6921 anupam.sin 3242 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3243 
    """
3244 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3245 
 
6805 anupam.sin 3246 
    Parameters:
3247 
     - itemId
6921 anupam.sin 3248 
     - price
6805 anupam.sin 3249 
     - insurerId
3250 
     - quantity
3251 
    """
6921 anupam.sin 3252 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3253 
    return self.recv_getInsuranceAmount()
3254 
 
6921 anupam.sin 3255 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3256 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3257 
    args = getInsuranceAmount_args()
3258 
    args.itemId = itemId
6921 anupam.sin 3259 
    args.price = price
6805 anupam.sin 3260 
    args.insurerId = insurerId
3261 
    args.quantity = quantity
3262 
    args.write(self._oprot)
3263 
    self._oprot.writeMessageEnd()
3264 
    self._oprot.trans.flush()
3265 
 
3266 
  def recv_getInsuranceAmount(self, ):
3267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3268 
    if mtype == TMessageType.EXCEPTION:
3269 
      x = TApplicationException()
3270 
      x.read(self._iprot)
3271 
      self._iprot.readMessageEnd()
3272 
      raise x
3273 
    result = getInsuranceAmount_result()
3274 
    result.read(self._iprot)
3275 
    self._iprot.readMessageEnd()
3276 
    if result.success is not None:
3277 
      return result.success
3278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3279 
 
3280 
  def getInsurer(self, insurerId):
3281 
    """
3282 
    Parameters:
3283 
     - insurerId
3284 
    """
3285 
    self.send_getInsurer(insurerId)
3286 
    return self.recv_getInsurer()
3287 
 
3288 
  def send_getInsurer(self, insurerId):
3289 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3290 
    args = getInsurer_args()
3291 
    args.insurerId = insurerId
3292 
    args.write(self._oprot)
3293 
    self._oprot.writeMessageEnd()
3294 
    self._oprot.trans.flush()
3295 
 
3296 
  def recv_getInsurer(self, ):
3297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3298 
    if mtype == TMessageType.EXCEPTION:
3299 
      x = TApplicationException()
3300 
      x.read(self._iprot)
3301 
      self._iprot.readMessageEnd()
3302 
      raise x
3303 
    result = getInsurer_result()
3304 
    result.read(self._iprot)
3305 
    self._iprot.readMessageEnd()
3306 
    if result.success is not None:
3307 
      return result.success
3308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3309 
 
6838 vikram.rag 3310 
  def getAllInsurers(self, ):
3311 
    self.send_getAllInsurers()
3312 
    return self.recv_getAllInsurers()
6805 anupam.sin 3313 
 
6838 vikram.rag 3314 
  def send_getAllInsurers(self, ):
3315 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3316 
    args = getAllInsurers_args()
3317 
    args.write(self._oprot)
3318 
    self._oprot.writeMessageEnd()
3319 
    self._oprot.trans.flush()
3320 
 
3321 
  def recv_getAllInsurers(self, ):
3322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3323 
    if mtype == TMessageType.EXCEPTION:
3324 
      x = TApplicationException()
3325 
      x.read(self._iprot)
3326 
      self._iprot.readMessageEnd()
3327 
      raise x
3328 
    result = getAllInsurers_result()
3329 
    result.read(self._iprot)
3330 
    self._iprot.readMessageEnd()
3331 
    if result.success is not None:
3332 
      return result.success
3333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3334 
 
6962 rajveer 3335 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3336 
    """
3337 
    Parameters:
3338 
     - insurerId
3339 
     - amount
3340 
    """
3341 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3342 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3343 
 
6962 rajveer 3344 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3345 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3346 
    args = updateInsuranceDeclaredAmount_args()
3347 
    args.insurerId = insurerId
3348 
    args.amount = amount
3349 
    args.write(self._oprot)
3350 
    self._oprot.writeMessageEnd()
3351 
    self._oprot.trans.flush()
3352 
 
3353 
  def recv_updateInsuranceDeclaredAmount(self, ):
3354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3355 
    if mtype == TMessageType.EXCEPTION:
3356 
      x = TApplicationException()
3357 
      x.read(self._iprot)
3358 
      self._iprot.readMessageEnd()
3359 
      raise x
3360 
    result = updateInsuranceDeclaredAmount_result()
3361 
    result.read(self._iprot)
3362 
    self._iprot.readMessageEnd()
3363 
    return
3364 
 
7190 amar.kumar 3365 
  def getFreebieForItem(self, itemId):
3366 
    """
3367 
    Parameters:
3368 
     - itemId
3369 
    """
3370 
    self.send_getFreebieForItem(itemId)
3371 
    return self.recv_getFreebieForItem()
6962 rajveer 3372 
 
7190 amar.kumar 3373 
  def send_getFreebieForItem(self, itemId):
3374 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3375 
    args = getFreebieForItem_args()
3376 
    args.itemId = itemId
3377 
    args.write(self._oprot)
3378 
    self._oprot.writeMessageEnd()
3379 
    self._oprot.trans.flush()
3380 
 
3381 
  def recv_getFreebieForItem(self, ):
3382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3383 
    if mtype == TMessageType.EXCEPTION:
3384 
      x = TApplicationException()
3385 
      x.read(self._iprot)
3386 
      self._iprot.readMessageEnd()
3387 
      raise x
3388 
    result = getFreebieForItem_result()
3389 
    result.read(self._iprot)
3390 
    self._iprot.readMessageEnd()
3391 
    if result.success is not None:
3392 
      return result.success
3393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3394 
 
3395 
  def addOrUpdateFreebieForItem(self, freebieItem):
3396 
    """
3397 
    Parameters:
3398 
     - freebieItem
3399 
    """
3400 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3401 
    self.recv_addOrUpdateFreebieForItem()
3402 
 
3403 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3404 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3405 
    args = addOrUpdateFreebieForItem_args()
3406 
    args.freebieItem = freebieItem
3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_addOrUpdateFreebieForItem(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = addOrUpdateFreebieForItem_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3421 
    return
3422 
 
7272 amit.gupta 3423 
  def addOrUpdateBrandInfo(self, brandInfo):
3424 
    """
3425 
    Parameters:
3426 
     - brandInfo
3427 
    """
3428 
    self.send_addOrUpdateBrandInfo(brandInfo)
3429 
    self.recv_addOrUpdateBrandInfo()
3430 
 
3431 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3432 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3433 
    args = addOrUpdateBrandInfo_args()
3434 
    args.brandInfo = brandInfo
3435 
    args.write(self._oprot)
3436 
    self._oprot.writeMessageEnd()
3437 
    self._oprot.trans.flush()
3438 
 
3439 
  def recv_addOrUpdateBrandInfo(self, ):
3440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3441 
    if mtype == TMessageType.EXCEPTION:
3442 
      x = TApplicationException()
3443 
      x.read(self._iprot)
3444 
      self._iprot.readMessageEnd()
3445 
      raise x
3446 
    result = addOrUpdateBrandInfo_result()
3447 
    result.read(self._iprot)
3448 
    self._iprot.readMessageEnd()
3449 
    return
3450 
 
3451 
  def getBrandInfo(self, ):
3452 
    self.send_getBrandInfo()
3453 
    return self.recv_getBrandInfo()
3454 
 
3455 
  def send_getBrandInfo(self, ):
3456 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3457 
    args = getBrandInfo_args()
3458 
    args.write(self._oprot)
3459 
    self._oprot.writeMessageEnd()
3460 
    self._oprot.trans.flush()
3461 
 
3462 
  def recv_getBrandInfo(self, ):
3463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3464 
    if mtype == TMessageType.EXCEPTION:
3465 
      x = TApplicationException()
3466 
      x.read(self._iprot)
3467 
      self._iprot.readMessageEnd()
3468 
      raise x
3469 
    result = getBrandInfo_result()
3470 
    result.read(self._iprot)
3471 
    self._iprot.readMessageEnd()
3472 
    if result.success is not None:
3473 
      return result.success
3474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3475 
 
7256 rajveer 3476 
  def getStorePricing(self, itemId):
3477 
    """
3478 
    Parameters:
3479 
     - itemId
3480 
    """
3481 
    self.send_getStorePricing(itemId)
3482 
    return self.recv_getStorePricing()
7190 amar.kumar 3483 
 
7256 rajveer 3484 
  def send_getStorePricing(self, itemId):
3485 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3486 
    args = getStorePricing_args()
3487 
    args.itemId = itemId
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_getStorePricing(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = getStorePricing_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3502 
    if result.success is not None:
3503 
      return result.success
3504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3505 
 
7306 rajveer 3506 
  def getStorePricings(self, itemIds):
3507 
    """
3508 
    Parameters:
3509 
     - itemIds
3510 
    """
3511 
    self.send_getStorePricings(itemIds)
3512 
    return self.recv_getStorePricings()
3513 
 
3514 
  def send_getStorePricings(self, itemIds):
3515 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3516 
    args = getStorePricings_args()
3517 
    args.itemIds = itemIds
3518 
    args.write(self._oprot)
3519 
    self._oprot.writeMessageEnd()
3520 
    self._oprot.trans.flush()
3521 
 
3522 
  def recv_getStorePricings(self, ):
3523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3524 
    if mtype == TMessageType.EXCEPTION:
3525 
      x = TApplicationException()
3526 
      x.read(self._iprot)
3527 
      self._iprot.readMessageEnd()
3528 
      raise x
3529 
    result = getStorePricings_result()
3530 
    result.read(self._iprot)
3531 
    self._iprot.readMessageEnd()
3532 
    if result.success is not None:
3533 
      return result.success
3534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3535 
 
7265 rajveer 3536 
  def updateStorePricing(self, sp):
3537 
    """
3538 
    Parameters:
3539 
     - sp
3540 
    """
3541 
    self.send_updateStorePricing(sp)
3542 
    self.recv_updateStorePricing()
7256 rajveer 3543 
 
7265 rajveer 3544 
  def send_updateStorePricing(self, sp):
3545 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3546 
    args = updateStorePricing_args()
3547 
    args.sp = sp
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_updateStorePricing(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = updateStorePricing_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3562 
    return
3563 
 
7281 kshitij.so 3564 
  def getAllAmazonListedItems(self, ):
3565 
    self.send_getAllAmazonListedItems()
3566 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3567 
 
7281 kshitij.so 3568 
  def send_getAllAmazonListedItems(self, ):
3569 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3570 
    args = getAllAmazonListedItems_args()
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_getAllAmazonListedItems(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = getAllAmazonListedItems_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3585 
    if result.success is not None:
3586 
      return result.success
3587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3588 
 
3589 
  def getAmazonItemDetails(self, itemId):
3590 
    """
3591 
    Parameters:
3592 
     - itemId
3593 
    """
3594 
    self.send_getAmazonItemDetails(itemId)
3595 
    return self.recv_getAmazonItemDetails()
3596 
 
3597 
  def send_getAmazonItemDetails(self, itemId):
3598 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3599 
    args = getAmazonItemDetails_args()
3600 
    args.itemId = itemId
3601 
    args.write(self._oprot)
3602 
    self._oprot.writeMessageEnd()
3603 
    self._oprot.trans.flush()
3604 
 
3605 
  def recv_getAmazonItemDetails(self, ):
3606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3607 
    if mtype == TMessageType.EXCEPTION:
3608 
      x = TApplicationException()
3609 
      x.read(self._iprot)
3610 
      self._iprot.readMessageEnd()
3611 
      raise x
3612 
    result = getAmazonItemDetails_result()
3613 
    result.read(self._iprot)
3614 
    self._iprot.readMessageEnd()
3615 
    if result.success is not None:
3616 
      return result.success
3617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3618 
 
3619 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3620 
    """
3621 
    Parameters:
3622 
     - itemId
3623 
     - fbaPrice
3624 
     - sellingPrice
3625 
     - isFba
3626 
     - isNonFba
3627 
     - isInventoryOverride
3628 
    """
3629 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride)
3630 
    self.recv_updateAmazonItemDetails()
3631 
 
3632 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3633 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3634 
    args = updateAmazonItemDetails_args()
3635 
    args.itemId = itemId
3636 
    args.fbaPrice = fbaPrice
3637 
    args.sellingPrice = sellingPrice
3638 
    args.isFba = isFba
3639 
    args.isNonFba = isNonFba
3640 
    args.isInventoryOverride = isInventoryOverride
3641 
    args.write(self._oprot)
3642 
    self._oprot.writeMessageEnd()
3643 
    self._oprot.trans.flush()
3644 
 
3645 
  def recv_updateAmazonItemDetails(self, ):
3646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3647 
    if mtype == TMessageType.EXCEPTION:
3648 
      x = TApplicationException()
3649 
      x.read(self._iprot)
3650 
      self._iprot.readMessageEnd()
3651 
      raise x
3652 
    result = updateAmazonItemDetails_result()
3653 
    result.read(self._iprot)
3654 
    self._iprot.readMessageEnd()
3655 
    return
3656 
 
3657 
  def addAmazonItem(self, amazonlisted):
3658 
    """
3659 
    Parameters:
3660 
     - amazonlisted
3661 
    """
3662 
    self.send_addAmazonItem(amazonlisted)
3663 
    self.recv_addAmazonItem()
3664 
 
3665 
  def send_addAmazonItem(self, amazonlisted):
3666 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3667 
    args = addAmazonItem_args()
3668 
    args.amazonlisted = amazonlisted
3669 
    args.write(self._oprot)
3670 
    self._oprot.writeMessageEnd()
3671 
    self._oprot.trans.flush()
3672 
 
3673 
  def recv_addAmazonItem(self, ):
3674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3675 
    if mtype == TMessageType.EXCEPTION:
3676 
      x = TApplicationException()
3677 
      x.read(self._iprot)
3678 
      self._iprot.readMessageEnd()
3679 
      raise x
3680 
    result = addAmazonItem_result()
3681 
    result.read(self._iprot)
3682 
    self._iprot.readMessageEnd()
3683 
    return
3684 
 
7291 vikram.rag 3685 
  def getAsinItems(self, ):
3686 
    self.send_getAsinItems()
3687 
    return self.recv_getAsinItems()
7281 kshitij.so 3688 
 
7291 vikram.rag 3689 
  def send_getAsinItems(self, ):
3690 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3691 
    args = getAsinItems_args()
3692 
    args.write(self._oprot)
3693 
    self._oprot.writeMessageEnd()
3694 
    self._oprot.trans.flush()
3695 
 
3696 
  def recv_getAsinItems(self, ):
3697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3698 
    if mtype == TMessageType.EXCEPTION:
3699 
      x = TApplicationException()
3700 
      x.read(self._iprot)
3701 
      self._iprot.readMessageEnd()
3702 
      raise x
3703 
    result = getAsinItems_result()
3704 
    result.read(self._iprot)
3705 
    self._iprot.readMessageEnd()
3706 
    if result.success is not None:
3707 
      return result.success
3708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3709 
 
3710 
  def getAllFbaListedItems(self, ):
3711 
    self.send_getAllFbaListedItems()
3712 
    return self.recv_getAllFbaListedItems()
3713 
 
3714 
  def send_getAllFbaListedItems(self, ):
3715 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3716 
    args = getAllFbaListedItems_args()
3717 
    args.write(self._oprot)
3718 
    self._oprot.writeMessageEnd()
3719 
    self._oprot.trans.flush()
3720 
 
3721 
  def recv_getAllFbaListedItems(self, ):
3722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3723 
    if mtype == TMessageType.EXCEPTION:
3724 
      x = TApplicationException()
3725 
      x.read(self._iprot)
3726 
      self._iprot.readMessageEnd()
3727 
      raise x
3728 
    result = getAllFbaListedItems_result()
3729 
    result.read(self._iprot)
3730 
    self._iprot.readMessageEnd()
3731 
    if result.success is not None:
3732 
      return result.success
3733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3734 
 
3735 
  def getAllNonFbaListedItems(self, ):
3736 
    self.send_getAllNonFbaListedItems()
3737 
    return self.recv_getAllNonFbaListedItems()
3738 
 
3739 
  def send_getAllNonFbaListedItems(self, ):
3740 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3741 
    args = getAllNonFbaListedItems_args()
3742 
    args.write(self._oprot)
3743 
    self._oprot.writeMessageEnd()
3744 
    self._oprot.trans.flush()
3745 
 
3746 
  def recv_getAllNonFbaListedItems(self, ):
3747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3748 
    if mtype == TMessageType.EXCEPTION:
3749 
      x = TApplicationException()
3750 
      x.read(self._iprot)
3751 
      self._iprot.readMessageEnd()
3752 
      raise x
3753 
    result = getAllNonFbaListedItems_result()
3754 
    result.read(self._iprot)
3755 
    self._iprot.readMessageEnd()
3756 
    if result.success is not None:
3757 
      return result.success
3758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3759 
 
3760 
 
5944 mandeep.dh 3761 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3762 
  def __init__(self, handler):
3763 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3764 
    self._processMap["addItem"] = Processor.process_addItem
3765 
    self._processMap["updateItem"] = Processor.process_updateItem
3766 
    self._processMap["isActive"] = Processor.process_isActive
3767 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3768 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3769 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3770 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3771 
    self._processMap["getItem"] = Processor.process_getItem
3772 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3773 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3774 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3775 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3776 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3777 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3778 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3779 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3780 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3781 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3782 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3783 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3784 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3785 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3786 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3787 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3788 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3789 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3790 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3791 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3792 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3793 
    self._processMap["addCategory"] = Processor.process_addCategory
3794 
    self._processMap["getCategory"] = Processor.process_getCategory
3795 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3796 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3797 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3798 
    self._processMap["addTag"] = Processor.process_addTag
3799 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3800 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3801 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3802 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3803 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3804 
    self._processMap["addBanner"] = Processor.process_addBanner
3805 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3806 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3807 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3808 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3809 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3810 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3811 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3812 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3813 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3814 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3815 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3816 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3817 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3818 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3819 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3820 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3821 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3822 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3823 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3824 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3825 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3826 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3827 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3828 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3829 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3830 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3831 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3832 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3833 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3834 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3835 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3836 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3837 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3838 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3839 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3840 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3841 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3842 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3843 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3844 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3845 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3846 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3847 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3848 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3849 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3850 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3851 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3852 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3853 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3854 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3855 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3856 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3857 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3858 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3859 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3860 
 
3861 
  def process(self, iprot, oprot):
3862 
    (name, type, seqid) = iprot.readMessageBegin()
3863 
    if name not in self._processMap:
3864 
      iprot.skip(TType.STRUCT)
3865 
      iprot.readMessageEnd()
3866 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3867 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3868 
      x.write(oprot)
3869 
      oprot.writeMessageEnd()
3870 
      oprot.trans.flush()
3871 
      return
3872 
    else:
3873 
      self._processMap[name](self, seqid, iprot, oprot)
3874 
    return True
3875 
 
3876 
  def process_addItem(self, seqid, iprot, oprot):
3877 
    args = addItem_args()
3878 
    args.read(iprot)
3879 
    iprot.readMessageEnd()
3880 
    result = addItem_result()
3881 
    try:
3882 
      result.success = self._handler.addItem(args.item)
3883 
    except CatalogServiceException, cex:
3884 
      result.cex = cex
3885 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3886 
    result.write(oprot)
3887 
    oprot.writeMessageEnd()
3888 
    oprot.trans.flush()
3889 
 
3890 
  def process_updateItem(self, seqid, iprot, oprot):
3891 
    args = updateItem_args()
3892 
    args.read(iprot)
3893 
    iprot.readMessageEnd()
3894 
    result = updateItem_result()
3895 
    try:
3896 
      result.success = self._handler.updateItem(args.item)
3897 
    except CatalogServiceException, cex:
3898 
      result.cex = cex
3899 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3900 
    result.write(oprot)
3901 
    oprot.writeMessageEnd()
3902 
    oprot.trans.flush()
3903 
 
3904 
  def process_isActive(self, seqid, iprot, oprot):
3905 
    args = isActive_args()
3906 
    args.read(iprot)
3907 
    iprot.readMessageEnd()
3908 
    result = isActive_result()
3909 
    try:
3910 
      result.success = self._handler.isActive(args.itemId)
3911 
    except CatalogServiceException, isex:
3912 
      result.isex = isex
3913 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3914 
    result.write(oprot)
3915 
    oprot.writeMessageEnd()
3916 
    oprot.trans.flush()
3917 
 
3918 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3919 
    args = getItemStatusDescription_args()
3920 
    args.read(iprot)
3921 
    iprot.readMessageEnd()
3922 
    result = getItemStatusDescription_result()
3923 
    try:
3924 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3925 
    except CatalogServiceException, isex:
3926 
      result.isex = isex
3927 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3928 
    result.write(oprot)
3929 
    oprot.writeMessageEnd()
3930 
    oprot.trans.flush()
3931 
 
3932 
  def process_startItemOn(self, seqid, iprot, oprot):
3933 
    args = startItemOn_args()
3934 
    args.read(iprot)
3935 
    iprot.readMessageEnd()
3936 
    result = startItemOn_result()
3937 
    try:
3938 
      self._handler.startItemOn(args.item_id, args.timestamp)
3939 
    except CatalogServiceException, cex:
3940 
      result.cex = cex
3941 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3942 
    result.write(oprot)
3943 
    oprot.writeMessageEnd()
3944 
    oprot.trans.flush()
3945 
 
3946 
  def process_retireItemOn(self, seqid, iprot, oprot):
3947 
    args = retireItemOn_args()
3948 
    args.read(iprot)
3949 
    iprot.readMessageEnd()
3950 
    result = retireItemOn_result()
3951 
    try:
3952 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3953 
    except CatalogServiceException, cex:
3954 
      result.cex = cex
3955 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3956 
    result.write(oprot)
3957 
    oprot.writeMessageEnd()
3958 
    oprot.trans.flush()
3959 
 
3960 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3961 
    args = changeItemStatus_args()
3962 
    args.read(iprot)
3963 
    iprot.readMessageEnd()
3964 
    result = changeItemStatus_result()
3965 
    try:
3966 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3967 
    except CatalogServiceException, cex:
3968 
      result.cex = cex
3969 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3970 
    result.write(oprot)
3971 
    oprot.writeMessageEnd()
3972 
    oprot.trans.flush()
3973 
 
3974 
  def process_getItem(self, seqid, iprot, oprot):
3975 
    args = getItem_args()
3976 
    args.read(iprot)
3977 
    iprot.readMessageEnd()
3978 
    result = getItem_result()
3979 
    try:
3980 
      result.success = self._handler.getItem(args.item_id)
3981 
    except CatalogServiceException, cex:
3982 
      result.cex = cex
3983 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3984 
    result.write(oprot)
3985 
    oprot.writeMessageEnd()
3986 
    oprot.trans.flush()
3987 
 
3988 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
3989 
    args = getItemsByCatalogId_args()
3990 
    args.read(iprot)
3991 
    iprot.readMessageEnd()
3992 
    result = getItemsByCatalogId_result()
3993 
    try:
3994 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
3995 
    except CatalogServiceException, cex:
3996 
      result.cex = cex
3997 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
3998 
    result.write(oprot)
3999 
    oprot.writeMessageEnd()
4000 
    oprot.trans.flush()
4001 
 
4002 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4003 
    args = getValidItemsByCatalogId_args()
4004 
    args.read(iprot)
4005 
    iprot.readMessageEnd()
4006 
    result = getValidItemsByCatalogId_result()
4007 
    try:
4008 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4009 
    except CatalogServiceException, cex:
4010 
      result.cex = cex
4011 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4012 
    result.write(oprot)
4013 
    oprot.writeMessageEnd()
4014 
    oprot.trans.flush()
4015 
 
4016 
  def process_getAllItems(self, seqid, iprot, oprot):
4017 
    args = getAllItems_args()
4018 
    args.read(iprot)
4019 
    iprot.readMessageEnd()
4020 
    result = getAllItems_result()
4021 
    try:
4022 
      result.success = self._handler.getAllItems(args.isActive)
4023 
    except CatalogServiceException, cex:
4024 
      result.cex = cex
4025 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4026 
    result.write(oprot)
4027 
    oprot.writeMessageEnd()
4028 
    oprot.trans.flush()
4029 
 
4030 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4031 
    args = getAllItemsByStatus_args()
4032 
    args.read(iprot)
4033 
    iprot.readMessageEnd()
4034 
    result = getAllItemsByStatus_result()
4035 
    try:
4036 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4037 
    except CatalogServiceException, cex:
4038 
      result.cex = cex
4039 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4040 
    result.write(oprot)
4041 
    oprot.writeMessageEnd()
4042 
    oprot.trans.flush()
4043 
 
4044 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4045 
    args = markItemAsContentComplete_args()
4046 
    args.read(iprot)
4047 
    iprot.readMessageEnd()
4048 
    result = markItemAsContentComplete_result()
4049 
    try:
4050 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4051 
    except CatalogServiceException, cex:
4052 
      result.cex = cex
4053 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4054 
    result.write(oprot)
4055 
    oprot.writeMessageEnd()
4056 
    oprot.trans.flush()
4057 
 
4058 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4059 
    args = getAllItemsInRange_args()
4060 
    args.read(iprot)
4061 
    iprot.readMessageEnd()
4062 
    result = getAllItemsInRange_result()
4063 
    try:
4064 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4065 
    except CatalogServiceException, cex:
4066 
      result.cex = cex
4067 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4068 
    result.write(oprot)
4069 
    oprot.writeMessageEnd()
4070 
    oprot.trans.flush()
4071 
 
4072 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4073 
    args = getAllItemsByStatusInRange_args()
4074 
    args.read(iprot)
4075 
    iprot.readMessageEnd()
4076 
    result = getAllItemsByStatusInRange_result()
4077 
    try:
4078 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4079 
    except CatalogServiceException, cex:
4080 
      result.cex = cex
4081 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4082 
    result.write(oprot)
4083 
    oprot.writeMessageEnd()
4084 
    oprot.trans.flush()
4085 
 
4086 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4087 
    args = getItemCountByStatus_args()
4088 
    args.read(iprot)
4089 
    iprot.readMessageEnd()
4090 
    result = getItemCountByStatus_result()
4091 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4092 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
4096 
 
4097 
  def process_getBestSellers(self, seqid, iprot, oprot):
4098 
    args = getBestSellers_args()
4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
4101 
    result = getBestSellers_result()
4102 
    try:
4103 
      result.success = self._handler.getBestSellers()
4104 
    except CatalogServiceException, isex:
4105 
      result.isex = isex
4106 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
4111 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4112 
    args = getBestSellersCatalogIds_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getBestSellersCatalogIds_result()
4116 
    try:
4117 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4118 
    except CatalogServiceException, cex:
4119 
      result.cex = cex
4120 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4121 
    result.write(oprot)
4122 
    oprot.writeMessageEnd()
4123 
    oprot.trans.flush()
4124 
 
4125 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4126 
    args = getBestSellersCount_args()
4127 
    args.read(iprot)
4128 
    iprot.readMessageEnd()
4129 
    result = getBestSellersCount_result()
4130 
    try:
4131 
      result.success = self._handler.getBestSellersCount()
4132 
    except CatalogServiceException, cex:
4133 
      result.cex = cex
4134 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4135 
    result.write(oprot)
4136 
    oprot.writeMessageEnd()
4137 
    oprot.trans.flush()
4138 
 
4139 
  def process_getBestDeals(self, seqid, iprot, oprot):
4140 
    args = getBestDeals_args()
4141 
    args.read(iprot)
4142 
    iprot.readMessageEnd()
4143 
    result = getBestDeals_result()
4144 
    try:
4145 
      result.success = self._handler.getBestDeals()
4146 
    except CatalogServiceException, isex:
4147 
      result.isex = isex
4148 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4149 
    result.write(oprot)
4150 
    oprot.writeMessageEnd()
4151 
    oprot.trans.flush()
4152 
 
4153 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4154 
    args = getBestDealsCatalogIds_args()
4155 
    args.read(iprot)
4156 
    iprot.readMessageEnd()
4157 
    result = getBestDealsCatalogIds_result()
4158 
    try:
4159 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4160 
    except CatalogServiceException, cex:
4161 
      result.cex = cex
4162 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4163 
    result.write(oprot)
4164 
    oprot.writeMessageEnd()
4165 
    oprot.trans.flush()
4166 
 
4167 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4168 
    args = getBestDealsCount_args()
4169 
    args.read(iprot)
4170 
    iprot.readMessageEnd()
4171 
    result = getBestDealsCount_result()
4172 
    try:
4173 
      result.success = self._handler.getBestDealsCount()
4174 
    except CatalogServiceException, cex:
4175 
      result.cex = cex
4176 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4177 
    result.write(oprot)
4178 
    oprot.writeMessageEnd()
4179 
    oprot.trans.flush()
4180 
 
4181 
  def process_getComingSoon(self, seqid, iprot, oprot):
4182 
    args = getComingSoon_args()
4183 
    args.read(iprot)
4184 
    iprot.readMessageEnd()
4185 
    result = getComingSoon_result()
4186 
    try:
4187 
      result.success = self._handler.getComingSoon()
4188 
    except CatalogServiceException, isex:
4189 
      result.isex = isex
4190 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4191 
    result.write(oprot)
4192 
    oprot.writeMessageEnd()
4193 
    oprot.trans.flush()
4194 
 
4195 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4196 
    args = getComingSoonCatalogIds_args()
4197 
    args.read(iprot)
4198 
    iprot.readMessageEnd()
4199 
    result = getComingSoonCatalogIds_result()
4200 
    try:
4201 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4202 
    except CatalogServiceException, cex:
4203 
      result.cex = cex
4204 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4205 
    result.write(oprot)
4206 
    oprot.writeMessageEnd()
4207 
    oprot.trans.flush()
4208 
 
4209 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4210 
    args = getComingSoonCount_args()
4211 
    args.read(iprot)
4212 
    iprot.readMessageEnd()
4213 
    result = getComingSoonCount_result()
4214 
    try:
4215 
      result.success = self._handler.getComingSoonCount()
4216 
    except CatalogServiceException, cex:
4217 
      result.cex = cex
4218 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
4223 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4224 
    args = getLatestArrivals_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = getLatestArrivals_result()
4228 
    try:
4229 
      result.success = self._handler.getLatestArrivals()
4230 
    except CatalogServiceException, isex:
4231 
      result.isex = isex
4232 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
4236 
 
4237 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4238 
    args = getLatestArrivalsCatalogIds_args()
4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
4241 
    result = getLatestArrivalsCatalogIds_result()
4242 
    try:
4243 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4244 
    except CatalogServiceException, cex:
4245 
      result.cex = cex
4246 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4247 
    result.write(oprot)
4248 
    oprot.writeMessageEnd()
4249 
    oprot.trans.flush()
4250 
 
4251 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4252 
    args = getLatestArrivalsCount_args()
4253 
    args.read(iprot)
4254 
    iprot.readMessageEnd()
4255 
    result = getLatestArrivalsCount_result()
4256 
    try:
4257 
      result.success = self._handler.getLatestArrivalsCount()
4258 
    except CatalogServiceException, cex:
4259 
      result.cex = cex
4260 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4261 
    result.write(oprot)
4262 
    oprot.writeMessageEnd()
4263 
    oprot.trans.flush()
4264 
 
4265 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4266 
    args = generateNewEntityID_args()
4267 
    args.read(iprot)
4268 
    iprot.readMessageEnd()
4269 
    result = generateNewEntityID_result()
4270 
    result.success = self._handler.generateNewEntityID()
4271 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
4275 
 
4276 
  def process_addCategory(self, seqid, iprot, oprot):
4277 
    args = addCategory_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = addCategory_result()
4281 
    result.success = self._handler.addCategory(args.category)
4282 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4283 
    result.write(oprot)
4284 
    oprot.writeMessageEnd()
4285 
    oprot.trans.flush()
4286 
 
4287 
  def process_getCategory(self, seqid, iprot, oprot):
4288 
    args = getCategory_args()
4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
4291 
    result = getCategory_result()
4292 
    result.success = self._handler.getCategory(args.id)
4293 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4294 
    result.write(oprot)
4295 
    oprot.writeMessageEnd()
4296 
    oprot.trans.flush()
4297 
 
4298 
  def process_getAllCategories(self, seqid, iprot, oprot):
4299 
    args = getAllCategories_args()
4300 
    args.read(iprot)
4301 
    iprot.readMessageEnd()
4302 
    result = getAllCategories_result()
4303 
    result.success = self._handler.getAllCategories()
4304 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4305 
    result.write(oprot)
4306 
    oprot.writeMessageEnd()
4307 
    oprot.trans.flush()
4308 
 
4309 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4310 
    args = getAllSimilarItems_args()
4311 
    args.read(iprot)
4312 
    iprot.readMessageEnd()
4313 
    result = getAllSimilarItems_result()
4314 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4315 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
4319 
 
4320 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4321 
    args = addSimilarItem_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = addSimilarItem_result()
4325 
    try:
4326 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4327 
    except CatalogServiceException, cex:
4328 
      result.cex = cex
4329 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4330 
    result.write(oprot)
4331 
    oprot.writeMessageEnd()
4332 
    oprot.trans.flush()
4333 
 
6512 kshitij.so 4334 
  def process_addTag(self, seqid, iprot, oprot):
4335 
    args = addTag_args()
4336 
    args.read(iprot)
4337 
    iprot.readMessageEnd()
4338 
    result = addTag_result()
4339 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4340 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4341 
    result.write(oprot)
4342 
    oprot.writeMessageEnd()
4343 
    oprot.trans.flush()
4344 
 
4345 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4346 
    args = deleteEntityTag_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = deleteEntityTag_result()
4350 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4351 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4352 
    result.write(oprot)
4353 
    oprot.writeMessageEnd()
4354 
    oprot.trans.flush()
4355 
 
4356 
  def process_deleteTag(self, seqid, iprot, oprot):
4357 
    args = deleteTag_args()
4358 
    args.read(iprot)
4359 
    iprot.readMessageEnd()
4360 
    result = deleteTag_result()
4361 
    result.success = self._handler.deleteTag(args.displayName)
4362 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4363 
    result.write(oprot)
4364 
    oprot.writeMessageEnd()
4365 
    oprot.trans.flush()
4366 
 
4367 
  def process_getAllTags(self, seqid, iprot, oprot):
4368 
    args = getAllTags_args()
4369 
    args.read(iprot)
4370 
    iprot.readMessageEnd()
4371 
    result = getAllTags_result()
4372 
    result.success = self._handler.getAllTags()
4373 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4374 
    result.write(oprot)
4375 
    oprot.writeMessageEnd()
4376 
    oprot.trans.flush()
4377 
 
4378 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4379 
    args = getAllEntitiesByTagName_args()
4380 
    args.read(iprot)
4381 
    iprot.readMessageEnd()
4382 
    result = getAllEntitiesByTagName_result()
4383 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4384 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4385 
    result.write(oprot)
4386 
    oprot.writeMessageEnd()
4387 
    oprot.trans.flush()
4388 
 
6845 amit.gupta 4389 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4390 
    args = getAllEntityTags_args()
4391 
    args.read(iprot)
4392 
    iprot.readMessageEnd()
4393 
    result = getAllEntityTags_result()
4394 
    result.success = self._handler.getAllEntityTags()
4395 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4396 
    result.write(oprot)
4397 
    oprot.writeMessageEnd()
4398 
    oprot.trans.flush()
4399 
 
6850 kshitij.so 4400 
  def process_addBanner(self, seqid, iprot, oprot):
4401 
    args = addBanner_args()
4402 
    args.read(iprot)
4403 
    iprot.readMessageEnd()
4404 
    result = addBanner_result()
4405 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4406 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4407 
    result.write(oprot)
4408 
    oprot.writeMessageEnd()
4409 
    oprot.trans.flush()
4410 
 
4411 
  def process_getAllBanners(self, seqid, iprot, oprot):
4412 
    args = getAllBanners_args()
4413 
    args.read(iprot)
4414 
    iprot.readMessageEnd()
4415 
    result = getAllBanners_result()
4416 
    result.success = self._handler.getAllBanners()
4417 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4418 
    result.write(oprot)
4419 
    oprot.writeMessageEnd()
4420 
    oprot.trans.flush()
4421 
 
4422 
  def process_deleteBanner(self, seqid, iprot, oprot):
4423 
    args = deleteBanner_args()
4424 
    args.read(iprot)
4425 
    iprot.readMessageEnd()
4426 
    result = deleteBanner_result()
4427 
    result.success = self._handler.deleteBanner(args.bannerName)
4428 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
4433 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4434 
    args = getBannerDetails_args()
4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
4437 
    result = getBannerDetails_result()
4438 
    result.success = self._handler.getBannerDetails(args.bannerName)
4439 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4440 
    result.write(oprot)
4441 
    oprot.writeMessageEnd()
4442 
    oprot.trans.flush()
4443 
 
4444 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4445 
    args = getActiveBanners_args()
4446 
    args.read(iprot)
4447 
    iprot.readMessageEnd()
4448 
    result = getActiveBanners_result()
4449 
    result.success = self._handler.getActiveBanners()
4450 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
4454 
 
6849 kshitij.so 4455 
  def process_addBannerMap(self, seqid, iprot, oprot):
4456 
    args = addBannerMap_args()
4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
4459 
    result = addBannerMap_result()
4460 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4461 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4462 
    result.write(oprot)
4463 
    oprot.writeMessageEnd()
4464 
    oprot.trans.flush()
4465 
 
4466 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4467 
    args = deleteBannerMap_args()
4468 
    args.read(iprot)
4469 
    iprot.readMessageEnd()
4470 
    result = deleteBannerMap_result()
4471 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4472 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
4477 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4478 
    args = getBannerMapDetails_args()
4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
4481 
    result = getBannerMapDetails_result()
4482 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4483 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4484 
    result.write(oprot)
4485 
    oprot.writeMessageEnd()
4486 
    oprot.trans.flush()
4487 
 
5944 mandeep.dh 4488 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4489 
    args = deleteSimilarItem_args()
4490 
    args.read(iprot)
4491 
    iprot.readMessageEnd()
4492 
    result = deleteSimilarItem_result()
4493 
    try:
4494 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4495 
    except CatalogServiceException, cex:
4496 
      result.cex = cex
4497 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4498 
    result.write(oprot)
4499 
    oprot.writeMessageEnd()
4500 
    oprot.trans.flush()
4501 
 
4502 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4503 
    args = checkSimilarItem_args()
4504 
    args.read(iprot)
4505 
    iprot.readMessageEnd()
4506 
    result = checkSimilarItem_result()
4507 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4508 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
4512 
 
4513 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4514 
    args = validateRiskyStatus_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = validateRiskyStatus_result()
4518 
    self._handler.validateRiskyStatus(args.itemId)
4519 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4520 
    result.write(oprot)
4521 
    oprot.writeMessageEnd()
4522 
    oprot.trans.flush()
4523 
 
4524 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4525 
    args = changeItemRiskyFlag_args()
4526 
    args.read(iprot)
4527 
    iprot.readMessageEnd()
4528 
    result = changeItemRiskyFlag_result()
4529 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4530 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4531 
    result.write(oprot)
4532 
    oprot.writeMessageEnd()
4533 
    oprot.trans.flush()
4534 
 
4535 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4536 
    args = getItemsByRiskyFlag_args()
4537 
    args.read(iprot)
4538 
    iprot.readMessageEnd()
4539 
    result = getItemsByRiskyFlag_result()
4540 
    result.success = self._handler.getItemsByRiskyFlag()
4541 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4542 
    result.write(oprot)
4543 
    oprot.writeMessageEnd()
4544 
    oprot.trans.flush()
4545 
 
4546 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4547 
    args = getItemsForMasterSheet_args()
4548 
    args.read(iprot)
4549 
    iprot.readMessageEnd()
4550 
    result = getItemsForMasterSheet_result()
4551 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4552 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4553 
    result.write(oprot)
4554 
    oprot.writeMessageEnd()
4555 
    oprot.trans.flush()
4556 
 
4557 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4558 
    args = getSimilarItemsCatalogIds_args()
4559 
    args.read(iprot)
4560 
    iprot.readMessageEnd()
4561 
    result = getSimilarItemsCatalogIds_result()
4562 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4563 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4564 
    result.write(oprot)
4565 
    oprot.writeMessageEnd()
4566 
    oprot.trans.flush()
4567 
 
4568 
  def process_addProductNotification(self, seqid, iprot, oprot):
4569 
    args = addProductNotification_args()
4570 
    args.read(iprot)
4571 
    iprot.readMessageEnd()
4572 
    result = addProductNotification_result()
4573 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4574 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4575 
    result.write(oprot)
4576 
    oprot.writeMessageEnd()
4577 
    oprot.trans.flush()
4578 
 
4579 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4580 
    args = sendProductNotifications_args()
4581 
    args.read(iprot)
4582 
    iprot.readMessageEnd()
4583 
    result = sendProductNotifications_result()
4584 
    result.success = self._handler.sendProductNotifications()
4585 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4586 
    result.write(oprot)
4587 
    oprot.writeMessageEnd()
4588 
    oprot.trans.flush()
4589 
 
4590 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4591 
    args = getAllBrandsByCategory_args()
4592 
    args.read(iprot)
4593 
    iprot.readMessageEnd()
4594 
    result = getAllBrandsByCategory_result()
4595 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4596 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4597 
    result.write(oprot)
4598 
    oprot.writeMessageEnd()
4599 
    oprot.trans.flush()
4600 
 
4601 
  def process_getAllBrands(self, seqid, iprot, oprot):
4602 
    args = getAllBrands_args()
4603 
    args.read(iprot)
4604 
    iprot.readMessageEnd()
4605 
    result = getAllBrands_result()
4606 
    result.success = self._handler.getAllBrands()
4607 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4608 
    result.write(oprot)
4609 
    oprot.writeMessageEnd()
4610 
    oprot.trans.flush()
4611 
 
4612 
  def process_getAllSources(self, seqid, iprot, oprot):
4613 
    args = getAllSources_args()
4614 
    args.read(iprot)
4615 
    iprot.readMessageEnd()
4616 
    result = getAllSources_result()
4617 
    result.success = self._handler.getAllSources()
4618 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4619 
    result.write(oprot)
4620 
    oprot.writeMessageEnd()
4621 
    oprot.trans.flush()
4622 
 
4623 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4624 
    args = getItemPricingBySource_args()
4625 
    args.read(iprot)
4626 
    iprot.readMessageEnd()
4627 
    result = getItemPricingBySource_result()
4628 
    try:
4629 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4630 
    except CatalogServiceException, cex:
4631 
      result.cex = cex
4632 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4633 
    result.write(oprot)
4634 
    oprot.writeMessageEnd()
4635 
    oprot.trans.flush()
4636 
 
4637 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4638 
    args = addSourceItemPricing_args()
4639 
    args.read(iprot)
4640 
    iprot.readMessageEnd()
4641 
    result = addSourceItemPricing_result()
4642 
    try:
4643 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4644 
    except CatalogServiceException, cex:
4645 
      result.cex = cex
4646 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4647 
    result.write(oprot)
4648 
    oprot.writeMessageEnd()
4649 
    oprot.trans.flush()
4650 
 
4651 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4652 
    args = getAllSourcePricing_args()
4653 
    args.read(iprot)
4654 
    iprot.readMessageEnd()
4655 
    result = getAllSourcePricing_result()
4656 
    try:
4657 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4658 
    except CatalogServiceException, cex:
4659 
      result.cex = cex
4660 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4661 
    result.write(oprot)
4662 
    oprot.writeMessageEnd()
4663 
    oprot.trans.flush()
4664 
 
4665 
  def process_getItemForSource(self, seqid, iprot, oprot):
4666 
    args = getItemForSource_args()
4667 
    args.read(iprot)
4668 
    iprot.readMessageEnd()
4669 
    result = getItemForSource_result()
4670 
    try:
4671 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4672 
    except CatalogServiceException, cex:
4673 
      result.cex = cex
4674 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4675 
    result.write(oprot)
4676 
    oprot.writeMessageEnd()
4677 
    oprot.trans.flush()
4678 
 
4679 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4680 
    args = searchItemsInRange_args()
4681 
    args.read(iprot)
4682 
    iprot.readMessageEnd()
4683 
    result = searchItemsInRange_result()
4684 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4685 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4686 
    result.write(oprot)
4687 
    oprot.writeMessageEnd()
4688 
    oprot.trans.flush()
4689 
 
4690 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4691 
    args = getSearchResultCount_args()
4692 
    args.read(iprot)
4693 
    iprot.readMessageEnd()
4694 
    result = getSearchResultCount_result()
4695 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4696 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4697 
    result.write(oprot)
4698 
    oprot.writeMessageEnd()
4699 
    oprot.trans.flush()
4700 
 
4701 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4702 
    args = getProductNotifications_args()
4703 
    args.read(iprot)
4704 
    iprot.readMessageEnd()
4705 
    result = getProductNotifications_result()
4706 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4707 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4708 
    result.write(oprot)
4709 
    oprot.writeMessageEnd()
4710 
    oprot.trans.flush()
4711 
 
4712 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4713 
    args = getProductNotificationRequestCount_args()
4714 
    args.read(iprot)
4715 
    iprot.readMessageEnd()
4716 
    result = getProductNotificationRequestCount_result()
4717 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4718 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4719 
    result.write(oprot)
4720 
    oprot.writeMessageEnd()
4721 
    oprot.trans.flush()
4722 
 
4723 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4724 
    args = addAuthorizationLog_args()
4725 
    args.read(iprot)
4726 
    iprot.readMessageEnd()
4727 
    result = addAuthorizationLog_result()
4728 
    try:
4729 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4730 
    except CatalogServiceException, cex:
4731 
      result.cex = cex
4732 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4733 
    result.write(oprot)
4734 
    oprot.writeMessageEnd()
4735 
    oprot.trans.flush()
4736 
 
4737 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4738 
    args = addupdateVoucherForItem_args()
4739 
    args.read(iprot)
4740 
    iprot.readMessageEnd()
4741 
    result = addupdateVoucherForItem_result()
4742 
    try:
4743 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4744 
    except CatalogServiceException, cex:
4745 
      result.cex = cex
4746 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4747 
    result.write(oprot)
4748 
    oprot.writeMessageEnd()
4749 
    oprot.trans.flush()
4750 
 
4751 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4752 
    args = deleteVoucherForItem_args()
4753 
    args.read(iprot)
4754 
    iprot.readMessageEnd()
4755 
    result = deleteVoucherForItem_result()
4756 
    try:
4757 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4758 
    except CatalogServiceException, cex:
4759 
      result.cex = cex
4760 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4761 
    result.write(oprot)
4762 
    oprot.writeMessageEnd()
4763 
    oprot.trans.flush()
4764 
 
4765 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4766 
    args = getVoucherAmount_args()
4767 
    args.read(iprot)
4768 
    iprot.readMessageEnd()
4769 
    result = getVoucherAmount_result()
4770 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4771 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
4776 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4777 
    args = getAllItemVouchers_args()
4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
4780 
    result = getAllItemVouchers_result()
4781 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4782 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4783 
    result.write(oprot)
4784 
    oprot.writeMessageEnd()
4785 
    oprot.trans.flush()
4786 
 
4787 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4788 
    args = isValidCatalogItemId_args()
4789 
    args.read(iprot)
4790 
    iprot.readMessageEnd()
4791 
    result = isValidCatalogItemId_result()
4792 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4793 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4794 
    result.write(oprot)
4795 
    oprot.writeMessageEnd()
4796 
    oprot.trans.flush()
4797 
 
6039 amit.gupta 4798 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4799 
    args = getVatPercentageForItem_args()
4800 
    args.read(iprot)
4801 
    iprot.readMessageEnd()
4802 
    result = getVatPercentageForItem_result()
7330 amit.gupta 4803 
    result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6039 amit.gupta 4804 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4805 
    result.write(oprot)
4806 
    oprot.writeMessageEnd()
4807 
    oprot.trans.flush()
5944 mandeep.dh 4808 
 
6039 amit.gupta 4809 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4810 
    args = getVatAmountForItem_args()
4811 
    args.read(iprot)
4812 
    iprot.readMessageEnd()
4813 
    result = getVatAmountForItem_result()
4814 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4815 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4816 
    result.write(oprot)
4817 
    oprot.writeMessageEnd()
4818 
    oprot.trans.flush()
4819 
 
6531 vikram.rag 4820 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4821 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4822 
    args.read(iprot)
4823 
    iprot.readMessageEnd()
4824 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4825 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4826 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4827 
    result.write(oprot)
4828 
    oprot.writeMessageEnd()
4829 
    oprot.trans.flush()
6039 amit.gupta 4830 
 
6821 amar.kumar 4831 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4832 
    args = getAllAliveItems_args()
4833 
    args.read(iprot)
4834 
    iprot.readMessageEnd()
4835 
    result = getAllAliveItems_result()
4836 
    result.success = self._handler.getAllAliveItems()
4837 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4838 
    result.write(oprot)
4839 
    oprot.writeMessageEnd()
4840 
    oprot.trans.flush()
4841 
 
6805 anupam.sin 4842 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4843 
    args = getInsuranceAmount_args()
4844 
    args.read(iprot)
4845 
    iprot.readMessageEnd()
4846 
    result = getInsuranceAmount_result()
6921 anupam.sin 4847 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4848 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4849 
    result.write(oprot)
4850 
    oprot.writeMessageEnd()
4851 
    oprot.trans.flush()
6531 vikram.rag 4852 
 
6805 anupam.sin 4853 
  def process_getInsurer(self, seqid, iprot, oprot):
4854 
    args = getInsurer_args()
4855 
    args.read(iprot)
4856 
    iprot.readMessageEnd()
4857 
    result = getInsurer_result()
4858 
    result.success = self._handler.getInsurer(args.insurerId)
4859 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4860 
    result.write(oprot)
4861 
    oprot.writeMessageEnd()
4862 
    oprot.trans.flush()
4863 
 
6838 vikram.rag 4864 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4865 
    args = getAllInsurers_args()
4866 
    args.read(iprot)
4867 
    iprot.readMessageEnd()
4868 
    result = getAllInsurers_result()
4869 
    result.success = self._handler.getAllInsurers()
4870 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4871 
    result.write(oprot)
4872 
    oprot.writeMessageEnd()
4873 
    oprot.trans.flush()
6805 anupam.sin 4874 
 
6962 rajveer 4875 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4876 
    args = updateInsuranceDeclaredAmount_args()
4877 
    args.read(iprot)
4878 
    iprot.readMessageEnd()
4879 
    result = updateInsuranceDeclaredAmount_result()
4880 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4881 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4882 
    result.write(oprot)
4883 
    oprot.writeMessageEnd()
4884 
    oprot.trans.flush()
6838 vikram.rag 4885 
 
7190 amar.kumar 4886 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4887 
    args = getFreebieForItem_args()
4888 
    args.read(iprot)
4889 
    iprot.readMessageEnd()
4890 
    result = getFreebieForItem_result()
4891 
    result.success = self._handler.getFreebieForItem(args.itemId)
4892 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4893 
    result.write(oprot)
4894 
    oprot.writeMessageEnd()
4895 
    oprot.trans.flush()
6962 rajveer 4896 
 
7190 amar.kumar 4897 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4898 
    args = addOrUpdateFreebieForItem_args()
4899 
    args.read(iprot)
4900 
    iprot.readMessageEnd()
4901 
    result = addOrUpdateFreebieForItem_result()
4902 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4903 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4904 
    result.write(oprot)
4905 
    oprot.writeMessageEnd()
4906 
    oprot.trans.flush()
4907 
 
7272 amit.gupta 4908 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4909 
    args = addOrUpdateBrandInfo_args()
4910 
    args.read(iprot)
4911 
    iprot.readMessageEnd()
4912 
    result = addOrUpdateBrandInfo_result()
4913 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4914 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4915 
    result.write(oprot)
4916 
    oprot.writeMessageEnd()
4917 
    oprot.trans.flush()
4918 
 
4919 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4920 
    args = getBrandInfo_args()
4921 
    args.read(iprot)
4922 
    iprot.readMessageEnd()
4923 
    result = getBrandInfo_result()
4924 
    result.success = self._handler.getBrandInfo()
4925 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4926 
    result.write(oprot)
4927 
    oprot.writeMessageEnd()
4928 
    oprot.trans.flush()
4929 
 
7256 rajveer 4930 
  def process_getStorePricing(self, seqid, iprot, oprot):
4931 
    args = getStorePricing_args()
4932 
    args.read(iprot)
4933 
    iprot.readMessageEnd()
4934 
    result = getStorePricing_result()
4935 
    result.success = self._handler.getStorePricing(args.itemId)
4936 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4937 
    result.write(oprot)
4938 
    oprot.writeMessageEnd()
4939 
    oprot.trans.flush()
7190 amar.kumar 4940 
 
7306 rajveer 4941 
  def process_getStorePricings(self, seqid, iprot, oprot):
4942 
    args = getStorePricings_args()
4943 
    args.read(iprot)
4944 
    iprot.readMessageEnd()
4945 
    result = getStorePricings_result()
4946 
    result.success = self._handler.getStorePricings(args.itemIds)
4947 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
4948 
    result.write(oprot)
4949 
    oprot.writeMessageEnd()
4950 
    oprot.trans.flush()
4951 
 
7265 rajveer 4952 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4953 
    args = updateStorePricing_args()
4954 
    args.read(iprot)
4955 
    iprot.readMessageEnd()
4956 
    result = updateStorePricing_result()
4957 
    self._handler.updateStorePricing(args.sp)
4958 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
7256 rajveer 4962 
 
7281 kshitij.so 4963 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4964 
    args = getAllAmazonListedItems_args()
4965 
    args.read(iprot)
4966 
    iprot.readMessageEnd()
4967 
    result = getAllAmazonListedItems_result()
4968 
    result.success = self._handler.getAllAmazonListedItems()
4969 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4970 
    result.write(oprot)
4971 
    oprot.writeMessageEnd()
4972 
    oprot.trans.flush()
7265 rajveer 4973 
 
7281 kshitij.so 4974 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4975 
    args = getAmazonItemDetails_args()
4976 
    args.read(iprot)
4977 
    iprot.readMessageEnd()
4978 
    result = getAmazonItemDetails_result()
4979 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4980 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
4984 
 
4985 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
4986 
    args = updateAmazonItemDetails_args()
4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
4989 
    result = updateAmazonItemDetails_result()
4990 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride)
4991 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
4992 
    result.write(oprot)
4993 
    oprot.writeMessageEnd()
4994 
    oprot.trans.flush()
4995 
 
4996 
  def process_addAmazonItem(self, seqid, iprot, oprot):
4997 
    args = addAmazonItem_args()
4998 
    args.read(iprot)
4999 
    iprot.readMessageEnd()
5000 
    result = addAmazonItem_result()
5001 
    self._handler.addAmazonItem(args.amazonlisted)
5002 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
7291 vikram.rag 5007 
  def process_getAsinItems(self, seqid, iprot, oprot):
5008 
    args = getAsinItems_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = getAsinItems_result()
5012 
    result.success = self._handler.getAsinItems()
5013 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5014 
    result.write(oprot)
5015 
    oprot.writeMessageEnd()
5016 
    oprot.trans.flush()
7281 kshitij.so 5017 
 
7291 vikram.rag 5018 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5019 
    args = getAllFbaListedItems_args()
5020 
    args.read(iprot)
5021 
    iprot.readMessageEnd()
5022 
    result = getAllFbaListedItems_result()
5023 
    result.success = self._handler.getAllFbaListedItems()
5024 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5025 
    result.write(oprot)
5026 
    oprot.writeMessageEnd()
5027 
    oprot.trans.flush()
5028 
 
5029 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5030 
    args = getAllNonFbaListedItems_args()
5031 
    args.read(iprot)
5032 
    iprot.readMessageEnd()
5033 
    result = getAllNonFbaListedItems_result()
5034 
    result.success = self._handler.getAllNonFbaListedItems()
5035 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5036 
    result.write(oprot)
5037 
    oprot.writeMessageEnd()
5038 
    oprot.trans.flush()
5039 
 
5040 
 
5944 mandeep.dh 5041 
# HELPER FUNCTIONS AND STRUCTURES
5042 
 
5043 
class addItem_args:
5044 
  """
5045 
  Attributes:
5046 
   - item
5047 
  """
5048 
 
5049 
  thrift_spec = (
5050 
    None, # 0
5051 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5052 
  )
5053 
 
5054 
  def __init__(self, item=None,):
5055 
    self.item = item
5056 
 
5057 
  def read(self, iprot):
5058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5060 
      return
5061 
    iprot.readStructBegin()
5062 
    while True:
5063 
      (fname, ftype, fid) = iprot.readFieldBegin()
5064 
      if ftype == TType.STOP:
5065 
        break
5066 
      if fid == 1:
5067 
        if ftype == TType.STRUCT:
5068 
          self.item = Item()
5069 
          self.item.read(iprot)
5070 
        else:
5071 
          iprot.skip(ftype)
5072 
      else:
5073 
        iprot.skip(ftype)
5074 
      iprot.readFieldEnd()
5075 
    iprot.readStructEnd()
5076 
 
5077 
  def write(self, oprot):
5078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5080 
      return
5081 
    oprot.writeStructBegin('addItem_args')
5082 
    if self.item is not None:
5083 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5084 
      self.item.write(oprot)
5085 
      oprot.writeFieldEnd()
5086 
    oprot.writeFieldStop()
5087 
    oprot.writeStructEnd()
5088 
 
5089 
  def validate(self):
5090 
    return
5091 
 
5092 
 
5093 
  def __repr__(self):
5094 
    L = ['%s=%r' % (key, value)
5095 
      for key, value in self.__dict__.iteritems()]
5096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5097 
 
5098 
  def __eq__(self, other):
5099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5100 
 
5101 
  def __ne__(self, other):
5102 
    return not (self == other)
5103 
 
5104 
class addItem_result:
5105 
  """
5106 
  Attributes:
5107 
   - success
5108 
   - cex
5109 
  """
5110 
 
5111 
  thrift_spec = (
5112 
    (0, TType.I64, 'success', None, None, ), # 0
5113 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5114 
  )
5115 
 
5116 
  def __init__(self, success=None, cex=None,):
5117 
    self.success = success
5118 
    self.cex = cex
5119 
 
5120 
  def read(self, iprot):
5121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5123 
      return
5124 
    iprot.readStructBegin()
5125 
    while True:
5126 
      (fname, ftype, fid) = iprot.readFieldBegin()
5127 
      if ftype == TType.STOP:
5128 
        break
5129 
      if fid == 0:
5130 
        if ftype == TType.I64:
5131 
          self.success = iprot.readI64();
5132 
        else:
5133 
          iprot.skip(ftype)
5134 
      elif fid == 1:
5135 
        if ftype == TType.STRUCT:
5136 
          self.cex = CatalogServiceException()
5137 
          self.cex.read(iprot)
5138 
        else:
5139 
          iprot.skip(ftype)
5140 
      else:
5141 
        iprot.skip(ftype)
5142 
      iprot.readFieldEnd()
5143 
    iprot.readStructEnd()
5144 
 
5145 
  def write(self, oprot):
5146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5148 
      return
5149 
    oprot.writeStructBegin('addItem_result')
5150 
    if self.success is not None:
5151 
      oprot.writeFieldBegin('success', TType.I64, 0)
5152 
      oprot.writeI64(self.success)
5153 
      oprot.writeFieldEnd()
5154 
    if self.cex is not None:
5155 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5156 
      self.cex.write(oprot)
5157 
      oprot.writeFieldEnd()
5158 
    oprot.writeFieldStop()
5159 
    oprot.writeStructEnd()
5160 
 
5161 
  def validate(self):
5162 
    return
5163 
 
5164 
 
5165 
  def __repr__(self):
5166 
    L = ['%s=%r' % (key, value)
5167 
      for key, value in self.__dict__.iteritems()]
5168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5169 
 
5170 
  def __eq__(self, other):
5171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5172 
 
5173 
  def __ne__(self, other):
5174 
    return not (self == other)
5175 
 
5176 
class updateItem_args:
5177 
  """
5178 
  Attributes:
5179 
   - item
5180 
  """
5181 
 
5182 
  thrift_spec = (
5183 
    None, # 0
5184 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5185 
  )
5186 
 
5187 
  def __init__(self, item=None,):
5188 
    self.item = item
5189 
 
5190 
  def read(self, iprot):
5191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5193 
      return
5194 
    iprot.readStructBegin()
5195 
    while True:
5196 
      (fname, ftype, fid) = iprot.readFieldBegin()
5197 
      if ftype == TType.STOP:
5198 
        break
5199 
      if fid == 1:
5200 
        if ftype == TType.STRUCT:
5201 
          self.item = Item()
5202 
          self.item.read(iprot)
5203 
        else:
5204 
          iprot.skip(ftype)
5205 
      else:
5206 
        iprot.skip(ftype)
5207 
      iprot.readFieldEnd()
5208 
    iprot.readStructEnd()
5209 
 
5210 
  def write(self, oprot):
5211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5213 
      return
5214 
    oprot.writeStructBegin('updateItem_args')
5215 
    if self.item is not None:
5216 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5217 
      self.item.write(oprot)
5218 
      oprot.writeFieldEnd()
5219 
    oprot.writeFieldStop()
5220 
    oprot.writeStructEnd()
5221 
 
5222 
  def validate(self):
5223 
    return
5224 
 
5225 
 
5226 
  def __repr__(self):
5227 
    L = ['%s=%r' % (key, value)
5228 
      for key, value in self.__dict__.iteritems()]
5229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5230 
 
5231 
  def __eq__(self, other):
5232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5233 
 
5234 
  def __ne__(self, other):
5235 
    return not (self == other)
5236 
 
5237 
class updateItem_result:
5238 
  """
5239 
  Attributes:
5240 
   - success
5241 
   - cex
5242 
  """
5243 
 
5244 
  thrift_spec = (
5245 
    (0, TType.I64, 'success', None, None, ), # 0
5246 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5247 
  )
5248 
 
5249 
  def __init__(self, success=None, cex=None,):
5250 
    self.success = success
5251 
    self.cex = cex
5252 
 
5253 
  def read(self, iprot):
5254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5256 
      return
5257 
    iprot.readStructBegin()
5258 
    while True:
5259 
      (fname, ftype, fid) = iprot.readFieldBegin()
5260 
      if ftype == TType.STOP:
5261 
        break
5262 
      if fid == 0:
5263 
        if ftype == TType.I64:
5264 
          self.success = iprot.readI64();
5265 
        else:
5266 
          iprot.skip(ftype)
5267 
      elif fid == 1:
5268 
        if ftype == TType.STRUCT:
5269 
          self.cex = CatalogServiceException()
5270 
          self.cex.read(iprot)
5271 
        else:
5272 
          iprot.skip(ftype)
5273 
      else:
5274 
        iprot.skip(ftype)
5275 
      iprot.readFieldEnd()
5276 
    iprot.readStructEnd()
5277 
 
5278 
  def write(self, oprot):
5279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5281 
      return
5282 
    oprot.writeStructBegin('updateItem_result')
5283 
    if self.success is not None:
5284 
      oprot.writeFieldBegin('success', TType.I64, 0)
5285 
      oprot.writeI64(self.success)
5286 
      oprot.writeFieldEnd()
5287 
    if self.cex is not None:
5288 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5289 
      self.cex.write(oprot)
5290 
      oprot.writeFieldEnd()
5291 
    oprot.writeFieldStop()
5292 
    oprot.writeStructEnd()
5293 
 
5294 
  def validate(self):
5295 
    return
5296 
 
5297 
 
5298 
  def __repr__(self):
5299 
    L = ['%s=%r' % (key, value)
5300 
      for key, value in self.__dict__.iteritems()]
5301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5302 
 
5303 
  def __eq__(self, other):
5304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5305 
 
5306 
  def __ne__(self, other):
5307 
    return not (self == other)
5308 
 
5309 
class isActive_args:
5310 
  """
5311 
  Attributes:
5312 
   - itemId
5313 
  """
5314 
 
5315 
  thrift_spec = (
5316 
    None, # 0
5317 
    (1, TType.I64, 'itemId', None, None, ), # 1
5318 
  )
5319 
 
5320 
  def __init__(self, itemId=None,):
5321 
    self.itemId = itemId
5322 
 
5323 
  def read(self, iprot):
5324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5326 
      return
5327 
    iprot.readStructBegin()
5328 
    while True:
5329 
      (fname, ftype, fid) = iprot.readFieldBegin()
5330 
      if ftype == TType.STOP:
5331 
        break
5332 
      if fid == 1:
5333 
        if ftype == TType.I64:
5334 
          self.itemId = iprot.readI64();
5335 
        else:
5336 
          iprot.skip(ftype)
5337 
      else:
5338 
        iprot.skip(ftype)
5339 
      iprot.readFieldEnd()
5340 
    iprot.readStructEnd()
5341 
 
5342 
  def write(self, oprot):
5343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5345 
      return
5346 
    oprot.writeStructBegin('isActive_args')
5347 
    if self.itemId is not None:
5348 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5349 
      oprot.writeI64(self.itemId)
5350 
      oprot.writeFieldEnd()
5351 
    oprot.writeFieldStop()
5352 
    oprot.writeStructEnd()
5353 
 
5354 
  def validate(self):
5355 
    return
5356 
 
5357 
 
5358 
  def __repr__(self):
5359 
    L = ['%s=%r' % (key, value)
5360 
      for key, value in self.__dict__.iteritems()]
5361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5362 
 
5363 
  def __eq__(self, other):
5364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5365 
 
5366 
  def __ne__(self, other):
5367 
    return not (self == other)
5368 
 
5369 
class isActive_result:
5370 
  """
5371 
  Attributes:
5372 
   - success
5373 
   - isex
5374 
  """
5375 
 
5376 
  thrift_spec = (
5377 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5378 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5379 
  )
5380 
 
5381 
  def __init__(self, success=None, isex=None,):
5382 
    self.success = success
5383 
    self.isex = isex
5384 
 
5385 
  def read(self, iprot):
5386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5388 
      return
5389 
    iprot.readStructBegin()
5390 
    while True:
5391 
      (fname, ftype, fid) = iprot.readFieldBegin()
5392 
      if ftype == TType.STOP:
5393 
        break
5394 
      if fid == 0:
5395 
        if ftype == TType.STRUCT:
5396 
          self.success = ItemShippingInfo()
5397 
          self.success.read(iprot)
5398 
        else:
5399 
          iprot.skip(ftype)
5400 
      elif fid == 1:
5401 
        if ftype == TType.STRUCT:
5402 
          self.isex = CatalogServiceException()
5403 
          self.isex.read(iprot)
5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      else:
5407 
        iprot.skip(ftype)
5408 
      iprot.readFieldEnd()
5409 
    iprot.readStructEnd()
5410 
 
5411 
  def write(self, oprot):
5412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5414 
      return
5415 
    oprot.writeStructBegin('isActive_result')
5416 
    if self.success is not None:
5417 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5418 
      self.success.write(oprot)
5419 
      oprot.writeFieldEnd()
5420 
    if self.isex is not None:
5421 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5422 
      self.isex.write(oprot)
5423 
      oprot.writeFieldEnd()
5424 
    oprot.writeFieldStop()
5425 
    oprot.writeStructEnd()
5426 
 
5427 
  def validate(self):
5428 
    return
5429 
 
5430 
 
5431 
  def __repr__(self):
5432 
    L = ['%s=%r' % (key, value)
5433 
      for key, value in self.__dict__.iteritems()]
5434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5435 
 
5436 
  def __eq__(self, other):
5437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5438 
 
5439 
  def __ne__(self, other):
5440 
    return not (self == other)
5441 
 
5442 
class getItemStatusDescription_args:
5443 
  """
5444 
  Attributes:
5445 
   - itemId
5446 
  """
5447 
 
5448 
  thrift_spec = (
5449 
    None, # 0
5450 
    (1, TType.I64, 'itemId', None, None, ), # 1
5451 
  )
5452 
 
5453 
  def __init__(self, itemId=None,):
5454 
    self.itemId = itemId
5455 
 
5456 
  def read(self, iprot):
5457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5459 
      return
5460 
    iprot.readStructBegin()
5461 
    while True:
5462 
      (fname, ftype, fid) = iprot.readFieldBegin()
5463 
      if ftype == TType.STOP:
5464 
        break
5465 
      if fid == 1:
5466 
        if ftype == TType.I64:
5467 
          self.itemId = iprot.readI64();
5468 
        else:
5469 
          iprot.skip(ftype)
5470 
      else:
5471 
        iprot.skip(ftype)
5472 
      iprot.readFieldEnd()
5473 
    iprot.readStructEnd()
5474 
 
5475 
  def write(self, oprot):
5476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5478 
      return
5479 
    oprot.writeStructBegin('getItemStatusDescription_args')
5480 
    if self.itemId is not None:
5481 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5482 
      oprot.writeI64(self.itemId)
5483 
      oprot.writeFieldEnd()
5484 
    oprot.writeFieldStop()
5485 
    oprot.writeStructEnd()
5486 
 
5487 
  def validate(self):
5488 
    return
5489 
 
5490 
 
5491 
  def __repr__(self):
5492 
    L = ['%s=%r' % (key, value)
5493 
      for key, value in self.__dict__.iteritems()]
5494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5495 
 
5496 
  def __eq__(self, other):
5497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5498 
 
5499 
  def __ne__(self, other):
5500 
    return not (self == other)
5501 
 
5502 
class getItemStatusDescription_result:
5503 
  """
5504 
  Attributes:
5505 
   - success
5506 
   - isex
5507 
  """
5508 
 
5509 
  thrift_spec = (
5510 
    (0, TType.STRING, 'success', None, None, ), # 0
5511 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5512 
  )
5513 
 
5514 
  def __init__(self, success=None, isex=None,):
5515 
    self.success = success
5516 
    self.isex = isex
5517 
 
5518 
  def read(self, iprot):
5519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5521 
      return
5522 
    iprot.readStructBegin()
5523 
    while True:
5524 
      (fname, ftype, fid) = iprot.readFieldBegin()
5525 
      if ftype == TType.STOP:
5526 
        break
5527 
      if fid == 0:
5528 
        if ftype == TType.STRING:
5529 
          self.success = iprot.readString();
5530 
        else:
5531 
          iprot.skip(ftype)
5532 
      elif fid == 1:
5533 
        if ftype == TType.STRUCT:
5534 
          self.isex = CatalogServiceException()
5535 
          self.isex.read(iprot)
5536 
        else:
5537 
          iprot.skip(ftype)
5538 
      else:
5539 
        iprot.skip(ftype)
5540 
      iprot.readFieldEnd()
5541 
    iprot.readStructEnd()
5542 
 
5543 
  def write(self, oprot):
5544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5546 
      return
5547 
    oprot.writeStructBegin('getItemStatusDescription_result')
5548 
    if self.success is not None:
5549 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5550 
      oprot.writeString(self.success)
5551 
      oprot.writeFieldEnd()
5552 
    if self.isex is not None:
5553 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5554 
      self.isex.write(oprot)
5555 
      oprot.writeFieldEnd()
5556 
    oprot.writeFieldStop()
5557 
    oprot.writeStructEnd()
5558 
 
5559 
  def validate(self):
5560 
    return
5561 
 
5562 
 
5563 
  def __repr__(self):
5564 
    L = ['%s=%r' % (key, value)
5565 
      for key, value in self.__dict__.iteritems()]
5566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5567 
 
5568 
  def __eq__(self, other):
5569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5570 
 
5571 
  def __ne__(self, other):
5572 
    return not (self == other)
5573 
 
5574 
class startItemOn_args:
5575 
  """
5576 
  Attributes:
5577 
   - item_id
5578 
   - timestamp
5579 
  """
5580 
 
5581 
  thrift_spec = (
5582 
    None, # 0
5583 
    (1, TType.I64, 'item_id', None, None, ), # 1
5584 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5585 
  )
5586 
 
5587 
  def __init__(self, item_id=None, timestamp=None,):
5588 
    self.item_id = item_id
5589 
    self.timestamp = timestamp
5590 
 
5591 
  def read(self, iprot):
5592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5594 
      return
5595 
    iprot.readStructBegin()
5596 
    while True:
5597 
      (fname, ftype, fid) = iprot.readFieldBegin()
5598 
      if ftype == TType.STOP:
5599 
        break
5600 
      if fid == 1:
5601 
        if ftype == TType.I64:
5602 
          self.item_id = iprot.readI64();
5603 
        else:
5604 
          iprot.skip(ftype)
5605 
      elif fid == 2:
5606 
        if ftype == TType.I64:
5607 
          self.timestamp = iprot.readI64();
5608 
        else:
5609 
          iprot.skip(ftype)
5610 
      else:
5611 
        iprot.skip(ftype)
5612 
      iprot.readFieldEnd()
5613 
    iprot.readStructEnd()
5614 
 
5615 
  def write(self, oprot):
5616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5618 
      return
5619 
    oprot.writeStructBegin('startItemOn_args')
5620 
    if self.item_id is not None:
5621 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5622 
      oprot.writeI64(self.item_id)
5623 
      oprot.writeFieldEnd()
5624 
    if self.timestamp is not None:
5625 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5626 
      oprot.writeI64(self.timestamp)
5627 
      oprot.writeFieldEnd()
5628 
    oprot.writeFieldStop()
5629 
    oprot.writeStructEnd()
5630 
 
5631 
  def validate(self):
5632 
    return
5633 
 
5634 
 
5635 
  def __repr__(self):
5636 
    L = ['%s=%r' % (key, value)
5637 
      for key, value in self.__dict__.iteritems()]
5638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5639 
 
5640 
  def __eq__(self, other):
5641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5642 
 
5643 
  def __ne__(self, other):
5644 
    return not (self == other)
5645 
 
5646 
class startItemOn_result:
5647 
  """
5648 
  Attributes:
5649 
   - cex
5650 
  """
5651 
 
5652 
  thrift_spec = (
5653 
    None, # 0
5654 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5655 
  )
5656 
 
5657 
  def __init__(self, cex=None,):
5658 
    self.cex = cex
5659 
 
5660 
  def read(self, iprot):
5661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5663 
      return
5664 
    iprot.readStructBegin()
5665 
    while True:
5666 
      (fname, ftype, fid) = iprot.readFieldBegin()
5667 
      if ftype == TType.STOP:
5668 
        break
5669 
      if fid == 1:
5670 
        if ftype == TType.STRUCT:
5671 
          self.cex = CatalogServiceException()
5672 
          self.cex.read(iprot)
5673 
        else:
5674 
          iprot.skip(ftype)
5675 
      else:
5676 
        iprot.skip(ftype)
5677 
      iprot.readFieldEnd()
5678 
    iprot.readStructEnd()
5679 
 
5680 
  def write(self, oprot):
5681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5683 
      return
5684 
    oprot.writeStructBegin('startItemOn_result')
5685 
    if self.cex is not None:
5686 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5687 
      self.cex.write(oprot)
5688 
      oprot.writeFieldEnd()
5689 
    oprot.writeFieldStop()
5690 
    oprot.writeStructEnd()
5691 
 
5692 
  def validate(self):
5693 
    return
5694 
 
5695 
 
5696 
  def __repr__(self):
5697 
    L = ['%s=%r' % (key, value)
5698 
      for key, value in self.__dict__.iteritems()]
5699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5700 
 
5701 
  def __eq__(self, other):
5702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5703 
 
5704 
  def __ne__(self, other):
5705 
    return not (self == other)
5706 
 
5707 
class retireItemOn_args:
5708 
  """
5709 
  Attributes:
5710 
   - item_id
5711 
   - timestamp
5712 
  """
5713 
 
5714 
  thrift_spec = (
5715 
    None, # 0
5716 
    (1, TType.I64, 'item_id', None, None, ), # 1
5717 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5718 
  )
5719 
 
5720 
  def __init__(self, item_id=None, timestamp=None,):
5721 
    self.item_id = item_id
5722 
    self.timestamp = timestamp
5723 
 
5724 
  def read(self, iprot):
5725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5727 
      return
5728 
    iprot.readStructBegin()
5729 
    while True:
5730 
      (fname, ftype, fid) = iprot.readFieldBegin()
5731 
      if ftype == TType.STOP:
5732 
        break
5733 
      if fid == 1:
5734 
        if ftype == TType.I64:
5735 
          self.item_id = iprot.readI64();
5736 
        else:
5737 
          iprot.skip(ftype)
5738 
      elif fid == 2:
5739 
        if ftype == TType.I64:
5740 
          self.timestamp = iprot.readI64();
5741 
        else:
5742 
          iprot.skip(ftype)
5743 
      else:
5744 
        iprot.skip(ftype)
5745 
      iprot.readFieldEnd()
5746 
    iprot.readStructEnd()
5747 
 
5748 
  def write(self, oprot):
5749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5751 
      return
5752 
    oprot.writeStructBegin('retireItemOn_args')
5753 
    if self.item_id is not None:
5754 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5755 
      oprot.writeI64(self.item_id)
5756 
      oprot.writeFieldEnd()
5757 
    if self.timestamp is not None:
5758 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5759 
      oprot.writeI64(self.timestamp)
5760 
      oprot.writeFieldEnd()
5761 
    oprot.writeFieldStop()
5762 
    oprot.writeStructEnd()
5763 
 
5764 
  def validate(self):
5765 
    return
5766 
 
5767 
 
5768 
  def __repr__(self):
5769 
    L = ['%s=%r' % (key, value)
5770 
      for key, value in self.__dict__.iteritems()]
5771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5772 
 
5773 
  def __eq__(self, other):
5774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5775 
 
5776 
  def __ne__(self, other):
5777 
    return not (self == other)
5778 
 
5779 
class retireItemOn_result:
5780 
  """
5781 
  Attributes:
5782 
   - cex
5783 
  """
5784 
 
5785 
  thrift_spec = (
5786 
    None, # 0
5787 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5788 
  )
5789 
 
5790 
  def __init__(self, cex=None,):
5791 
    self.cex = cex
5792 
 
5793 
  def read(self, iprot):
5794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5796 
      return
5797 
    iprot.readStructBegin()
5798 
    while True:
5799 
      (fname, ftype, fid) = iprot.readFieldBegin()
5800 
      if ftype == TType.STOP:
5801 
        break
5802 
      if fid == 1:
5803 
        if ftype == TType.STRUCT:
5804 
          self.cex = CatalogServiceException()
5805 
          self.cex.read(iprot)
5806 
        else:
5807 
          iprot.skip(ftype)
5808 
      else:
5809 
        iprot.skip(ftype)
5810 
      iprot.readFieldEnd()
5811 
    iprot.readStructEnd()
5812 
 
5813 
  def write(self, oprot):
5814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5816 
      return
5817 
    oprot.writeStructBegin('retireItemOn_result')
5818 
    if self.cex is not None:
5819 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5820 
      self.cex.write(oprot)
5821 
      oprot.writeFieldEnd()
5822 
    oprot.writeFieldStop()
5823 
    oprot.writeStructEnd()
5824 
 
5825 
  def validate(self):
5826 
    return
5827 
 
5828 
 
5829 
  def __repr__(self):
5830 
    L = ['%s=%r' % (key, value)
5831 
      for key, value in self.__dict__.iteritems()]
5832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5833 
 
5834 
  def __eq__(self, other):
5835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5836 
 
5837 
  def __ne__(self, other):
5838 
    return not (self == other)
5839 
 
5840 
class changeItemStatus_args:
5841 
  """
5842 
  Attributes:
5843 
   - item_id
5844 
   - timestamp
5845 
   - newstatus
5846 
  """
5847 
 
5848 
  thrift_spec = (
5849 
    None, # 0
5850 
    (1, TType.I64, 'item_id', None, None, ), # 1
5851 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5852 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5853 
  )
5854 
 
5855 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5856 
    self.item_id = item_id
5857 
    self.timestamp = timestamp
5858 
    self.newstatus = newstatus
5859 
 
5860 
  def read(self, iprot):
5861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5863 
      return
5864 
    iprot.readStructBegin()
5865 
    while True:
5866 
      (fname, ftype, fid) = iprot.readFieldBegin()
5867 
      if ftype == TType.STOP:
5868 
        break
5869 
      if fid == 1:
5870 
        if ftype == TType.I64:
5871 
          self.item_id = iprot.readI64();
5872 
        else:
5873 
          iprot.skip(ftype)
5874 
      elif fid == 2:
5875 
        if ftype == TType.I64:
5876 
          self.timestamp = iprot.readI64();
5877 
        else:
5878 
          iprot.skip(ftype)
5879 
      elif fid == 3:
5880 
        if ftype == TType.I32:
5881 
          self.newstatus = iprot.readI32();
5882 
        else:
5883 
          iprot.skip(ftype)
5884 
      else:
5885 
        iprot.skip(ftype)
5886 
      iprot.readFieldEnd()
5887 
    iprot.readStructEnd()
5888 
 
5889 
  def write(self, oprot):
5890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5892 
      return
5893 
    oprot.writeStructBegin('changeItemStatus_args')
5894 
    if self.item_id is not None:
5895 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5896 
      oprot.writeI64(self.item_id)
5897 
      oprot.writeFieldEnd()
5898 
    if self.timestamp is not None:
5899 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5900 
      oprot.writeI64(self.timestamp)
5901 
      oprot.writeFieldEnd()
5902 
    if self.newstatus is not None:
5903 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5904 
      oprot.writeI32(self.newstatus)
5905 
      oprot.writeFieldEnd()
5906 
    oprot.writeFieldStop()
5907 
    oprot.writeStructEnd()
5908 
 
5909 
  def validate(self):
5910 
    return
5911 
 
5912 
 
5913 
  def __repr__(self):
5914 
    L = ['%s=%r' % (key, value)
5915 
      for key, value in self.__dict__.iteritems()]
5916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5917 
 
5918 
  def __eq__(self, other):
5919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5920 
 
5921 
  def __ne__(self, other):
5922 
    return not (self == other)
5923 
 
5924 
class changeItemStatus_result:
5925 
  """
5926 
  Attributes:
5927 
   - cex
5928 
  """
5929 
 
5930 
  thrift_spec = (
5931 
    None, # 0
5932 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5933 
  )
5934 
 
5935 
  def __init__(self, cex=None,):
5936 
    self.cex = cex
5937 
 
5938 
  def read(self, iprot):
5939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5941 
      return
5942 
    iprot.readStructBegin()
5943 
    while True:
5944 
      (fname, ftype, fid) = iprot.readFieldBegin()
5945 
      if ftype == TType.STOP:
5946 
        break
5947 
      if fid == 1:
5948 
        if ftype == TType.STRUCT:
5949 
          self.cex = CatalogServiceException()
5950 
          self.cex.read(iprot)
5951 
        else:
5952 
          iprot.skip(ftype)
5953 
      else:
5954 
        iprot.skip(ftype)
5955 
      iprot.readFieldEnd()
5956 
    iprot.readStructEnd()
5957 
 
5958 
  def write(self, oprot):
5959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5961 
      return
5962 
    oprot.writeStructBegin('changeItemStatus_result')
5963 
    if self.cex is not None:
5964 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5965 
      self.cex.write(oprot)
5966 
      oprot.writeFieldEnd()
5967 
    oprot.writeFieldStop()
5968 
    oprot.writeStructEnd()
5969 
 
5970 
  def validate(self):
5971 
    return
5972 
 
5973 
 
5974 
  def __repr__(self):
5975 
    L = ['%s=%r' % (key, value)
5976 
      for key, value in self.__dict__.iteritems()]
5977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5978 
 
5979 
  def __eq__(self, other):
5980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5981 
 
5982 
  def __ne__(self, other):
5983 
    return not (self == other)
5984 
 
5985 
class getItem_args:
5986 
  """
5987 
  Attributes:
5988 
   - item_id
5989 
  """
5990 
 
5991 
  thrift_spec = (
5992 
    None, # 0
5993 
    (1, TType.I64, 'item_id', None, None, ), # 1
5994 
  )
5995 
 
5996 
  def __init__(self, item_id=None,):
5997 
    self.item_id = item_id
5998 
 
5999 
  def read(self, iprot):
6000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6002 
      return
6003 
    iprot.readStructBegin()
6004 
    while True:
6005 
      (fname, ftype, fid) = iprot.readFieldBegin()
6006 
      if ftype == TType.STOP:
6007 
        break
6008 
      if fid == 1:
6009 
        if ftype == TType.I64:
6010 
          self.item_id = iprot.readI64();
6011 
        else:
6012 
          iprot.skip(ftype)
6013 
      else:
6014 
        iprot.skip(ftype)
6015 
      iprot.readFieldEnd()
6016 
    iprot.readStructEnd()
6017 
 
6018 
  def write(self, oprot):
6019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6021 
      return
6022 
    oprot.writeStructBegin('getItem_args')
6023 
    if self.item_id is not None:
6024 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6025 
      oprot.writeI64(self.item_id)
6026 
      oprot.writeFieldEnd()
6027 
    oprot.writeFieldStop()
6028 
    oprot.writeStructEnd()
6029 
 
6030 
  def validate(self):
6031 
    return
6032 
 
6033 
 
6034 
  def __repr__(self):
6035 
    L = ['%s=%r' % (key, value)
6036 
      for key, value in self.__dict__.iteritems()]
6037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6038 
 
6039 
  def __eq__(self, other):
6040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6041 
 
6042 
  def __ne__(self, other):
6043 
    return not (self == other)
6044 
 
6045 
class getItem_result:
6046 
  """
6047 
  Attributes:
6048 
   - success
6049 
   - cex
6050 
  """
6051 
 
6052 
  thrift_spec = (
6053 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6054 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6055 
  )
6056 
 
6057 
  def __init__(self, success=None, cex=None,):
6058 
    self.success = success
6059 
    self.cex = cex
6060 
 
6061 
  def read(self, iprot):
6062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6064 
      return
6065 
    iprot.readStructBegin()
6066 
    while True:
6067 
      (fname, ftype, fid) = iprot.readFieldBegin()
6068 
      if ftype == TType.STOP:
6069 
        break
6070 
      if fid == 0:
6071 
        if ftype == TType.STRUCT:
6072 
          self.success = Item()
6073 
          self.success.read(iprot)
6074 
        else:
6075 
          iprot.skip(ftype)
6076 
      elif fid == 1:
6077 
        if ftype == TType.STRUCT:
6078 
          self.cex = CatalogServiceException()
6079 
          self.cex.read(iprot)
6080 
        else:
6081 
          iprot.skip(ftype)
6082 
      else:
6083 
        iprot.skip(ftype)
6084 
      iprot.readFieldEnd()
6085 
    iprot.readStructEnd()
6086 
 
6087 
  def write(self, oprot):
6088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6090 
      return
6091 
    oprot.writeStructBegin('getItem_result')
6092 
    if self.success is not None:
6093 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6094 
      self.success.write(oprot)
6095 
      oprot.writeFieldEnd()
6096 
    if self.cex is not None:
6097 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6098 
      self.cex.write(oprot)
6099 
      oprot.writeFieldEnd()
6100 
    oprot.writeFieldStop()
6101 
    oprot.writeStructEnd()
6102 
 
6103 
  def validate(self):
6104 
    return
6105 
 
6106 
 
6107 
  def __repr__(self):
6108 
    L = ['%s=%r' % (key, value)
6109 
      for key, value in self.__dict__.iteritems()]
6110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6111 
 
6112 
  def __eq__(self, other):
6113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6114 
 
6115 
  def __ne__(self, other):
6116 
    return not (self == other)
6117 
 
6118 
class getItemsByCatalogId_args:
6119 
  """
6120 
  Attributes:
6121 
   - catalog_item_id
6122 
  """
6123 
 
6124 
  thrift_spec = (
6125 
    None, # 0
6126 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6127 
  )
6128 
 
6129 
  def __init__(self, catalog_item_id=None,):
6130 
    self.catalog_item_id = catalog_item_id
6131 
 
6132 
  def read(self, iprot):
6133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6135 
      return
6136 
    iprot.readStructBegin()
6137 
    while True:
6138 
      (fname, ftype, fid) = iprot.readFieldBegin()
6139 
      if ftype == TType.STOP:
6140 
        break
6141 
      if fid == 1:
6142 
        if ftype == TType.I64:
6143 
          self.catalog_item_id = iprot.readI64();
6144 
        else:
6145 
          iprot.skip(ftype)
6146 
      else:
6147 
        iprot.skip(ftype)
6148 
      iprot.readFieldEnd()
6149 
    iprot.readStructEnd()
6150 
 
6151 
  def write(self, oprot):
6152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6154 
      return
6155 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6156 
    if self.catalog_item_id is not None:
6157 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6158 
      oprot.writeI64(self.catalog_item_id)
6159 
      oprot.writeFieldEnd()
6160 
    oprot.writeFieldStop()
6161 
    oprot.writeStructEnd()
6162 
 
6163 
  def validate(self):
6164 
    return
6165 
 
6166 
 
6167 
  def __repr__(self):
6168 
    L = ['%s=%r' % (key, value)
6169 
      for key, value in self.__dict__.iteritems()]
6170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6171 
 
6172 
  def __eq__(self, other):
6173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6174 
 
6175 
  def __ne__(self, other):
6176 
    return not (self == other)
6177 
 
6178 
class getItemsByCatalogId_result:
6179 
  """
6180 
  Attributes:
6181 
   - success
6182 
   - cex
6183 
  """
6184 
 
6185 
  thrift_spec = (
6186 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6187 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6188 
  )
6189 
 
6190 
  def __init__(self, success=None, cex=None,):
6191 
    self.success = success
6192 
    self.cex = cex
6193 
 
6194 
  def read(self, iprot):
6195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6197 
      return
6198 
    iprot.readStructBegin()
6199 
    while True:
6200 
      (fname, ftype, fid) = iprot.readFieldBegin()
6201 
      if ftype == TType.STOP:
6202 
        break
6203 
      if fid == 0:
6204 
        if ftype == TType.LIST:
6205 
          self.success = []
6206 
          (_etype19, _size16) = iprot.readListBegin()
6207 
          for _i20 in xrange(_size16):
6208 
            _elem21 = Item()
6209 
            _elem21.read(iprot)
6210 
            self.success.append(_elem21)
6211 
          iprot.readListEnd()
6212 
        else:
6213 
          iprot.skip(ftype)
6214 
      elif fid == 1:
6215 
        if ftype == TType.STRUCT:
6216 
          self.cex = CatalogServiceException()
6217 
          self.cex.read(iprot)
6218 
        else:
6219 
          iprot.skip(ftype)
6220 
      else:
6221 
        iprot.skip(ftype)
6222 
      iprot.readFieldEnd()
6223 
    iprot.readStructEnd()
6224 
 
6225 
  def write(self, oprot):
6226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6228 
      return
6229 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6230 
    if self.success is not None:
6231 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6232 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6233 
      for iter22 in self.success:
6234 
        iter22.write(oprot)
6235 
      oprot.writeListEnd()
6236 
      oprot.writeFieldEnd()
6237 
    if self.cex is not None:
6238 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6239 
      self.cex.write(oprot)
6240 
      oprot.writeFieldEnd()
6241 
    oprot.writeFieldStop()
6242 
    oprot.writeStructEnd()
6243 
 
6244 
  def validate(self):
6245 
    return
6246 
 
6247 
 
6248 
  def __repr__(self):
6249 
    L = ['%s=%r' % (key, value)
6250 
      for key, value in self.__dict__.iteritems()]
6251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6252 
 
6253 
  def __eq__(self, other):
6254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6255 
 
6256 
  def __ne__(self, other):
6257 
    return not (self == other)
6258 
 
6259 
class getValidItemsByCatalogId_args:
6260 
  """
6261 
  Attributes:
6262 
   - catalog_item_id
6263 
  """
6264 
 
6265 
  thrift_spec = (
6266 
    None, # 0
6267 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6268 
  )
6269 
 
6270 
  def __init__(self, catalog_item_id=None,):
6271 
    self.catalog_item_id = catalog_item_id
6272 
 
6273 
  def read(self, iprot):
6274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6276 
      return
6277 
    iprot.readStructBegin()
6278 
    while True:
6279 
      (fname, ftype, fid) = iprot.readFieldBegin()
6280 
      if ftype == TType.STOP:
6281 
        break
6282 
      if fid == 1:
6283 
        if ftype == TType.I64:
6284 
          self.catalog_item_id = iprot.readI64();
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      else:
6288 
        iprot.skip(ftype)
6289 
      iprot.readFieldEnd()
6290 
    iprot.readStructEnd()
6291 
 
6292 
  def write(self, oprot):
6293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6295 
      return
6296 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6297 
    if self.catalog_item_id is not None:
6298 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6299 
      oprot.writeI64(self.catalog_item_id)
6300 
      oprot.writeFieldEnd()
6301 
    oprot.writeFieldStop()
6302 
    oprot.writeStructEnd()
6303 
 
6304 
  def validate(self):
6305 
    return
6306 
 
6307 
 
6308 
  def __repr__(self):
6309 
    L = ['%s=%r' % (key, value)
6310 
      for key, value in self.__dict__.iteritems()]
6311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6312 
 
6313 
  def __eq__(self, other):
6314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6315 
 
6316 
  def __ne__(self, other):
6317 
    return not (self == other)
6318 
 
6319 
class getValidItemsByCatalogId_result:
6320 
  """
6321 
  Attributes:
6322 
   - success
6323 
   - cex
6324 
  """
6325 
 
6326 
  thrift_spec = (
6327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6328 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6329 
  )
6330 
 
6331 
  def __init__(self, success=None, cex=None,):
6332 
    self.success = success
6333 
    self.cex = cex
6334 
 
6335 
  def read(self, iprot):
6336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6338 
      return
6339 
    iprot.readStructBegin()
6340 
    while True:
6341 
      (fname, ftype, fid) = iprot.readFieldBegin()
6342 
      if ftype == TType.STOP:
6343 
        break
6344 
      if fid == 0:
6345 
        if ftype == TType.LIST:
6346 
          self.success = []
6347 
          (_etype26, _size23) = iprot.readListBegin()
6348 
          for _i27 in xrange(_size23):
6349 
            _elem28 = Item()
6350 
            _elem28.read(iprot)
6351 
            self.success.append(_elem28)
6352 
          iprot.readListEnd()
6353 
        else:
6354 
          iprot.skip(ftype)
6355 
      elif fid == 1:
6356 
        if ftype == TType.STRUCT:
6357 
          self.cex = CatalogServiceException()
6358 
          self.cex.read(iprot)
6359 
        else:
6360 
          iprot.skip(ftype)
6361 
      else:
6362 
        iprot.skip(ftype)
6363 
      iprot.readFieldEnd()
6364 
    iprot.readStructEnd()
6365 
 
6366 
  def write(self, oprot):
6367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6369 
      return
6370 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6371 
    if self.success is not None:
6372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6374 
      for iter29 in self.success:
6375 
        iter29.write(oprot)
6376 
      oprot.writeListEnd()
6377 
      oprot.writeFieldEnd()
6378 
    if self.cex is not None:
6379 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6380 
      self.cex.write(oprot)
6381 
      oprot.writeFieldEnd()
6382 
    oprot.writeFieldStop()
6383 
    oprot.writeStructEnd()
6384 
 
6385 
  def validate(self):
6386 
    return
6387 
 
6388 
 
6389 
  def __repr__(self):
6390 
    L = ['%s=%r' % (key, value)
6391 
      for key, value in self.__dict__.iteritems()]
6392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6393 
 
6394 
  def __eq__(self, other):
6395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6396 
 
6397 
  def __ne__(self, other):
6398 
    return not (self == other)
6399 
 
6400 
class getAllItems_args:
6401 
  """
6402 
  Attributes:
6403 
   - isActive
6404 
  """
6405 
 
6406 
  thrift_spec = (
6407 
    None, # 0
6408 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6409 
  )
6410 
 
6411 
  def __init__(self, isActive=None,):
6412 
    self.isActive = isActive
6413 
 
6414 
  def read(self, iprot):
6415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6417 
      return
6418 
    iprot.readStructBegin()
6419 
    while True:
6420 
      (fname, ftype, fid) = iprot.readFieldBegin()
6421 
      if ftype == TType.STOP:
6422 
        break
6423 
      if fid == 1:
6424 
        if ftype == TType.BOOL:
6425 
          self.isActive = iprot.readBool();
6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      else:
6429 
        iprot.skip(ftype)
6430 
      iprot.readFieldEnd()
6431 
    iprot.readStructEnd()
6432 
 
6433 
  def write(self, oprot):
6434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6436 
      return
6437 
    oprot.writeStructBegin('getAllItems_args')
6438 
    if self.isActive is not None:
6439 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6440 
      oprot.writeBool(self.isActive)
6441 
      oprot.writeFieldEnd()
6442 
    oprot.writeFieldStop()
6443 
    oprot.writeStructEnd()
6444 
 
6445 
  def validate(self):
6446 
    return
6447 
 
6448 
 
6449 
  def __repr__(self):
6450 
    L = ['%s=%r' % (key, value)
6451 
      for key, value in self.__dict__.iteritems()]
6452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6453 
 
6454 
  def __eq__(self, other):
6455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6456 
 
6457 
  def __ne__(self, other):
6458 
    return not (self == other)
6459 
 
6460 
class getAllItems_result:
6461 
  """
6462 
  Attributes:
6463 
   - success
6464 
   - cex
6465 
  """
6466 
 
6467 
  thrift_spec = (
6468 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6469 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6470 
  )
6471 
 
6472 
  def __init__(self, success=None, cex=None,):
6473 
    self.success = success
6474 
    self.cex = cex
6475 
 
6476 
  def read(self, iprot):
6477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6479 
      return
6480 
    iprot.readStructBegin()
6481 
    while True:
6482 
      (fname, ftype, fid) = iprot.readFieldBegin()
6483 
      if ftype == TType.STOP:
6484 
        break
6485 
      if fid == 0:
6486 
        if ftype == TType.LIST:
6487 
          self.success = []
6488 
          (_etype33, _size30) = iprot.readListBegin()
6489 
          for _i34 in xrange(_size30):
6490 
            _elem35 = Item()
6491 
            _elem35.read(iprot)
6492 
            self.success.append(_elem35)
6493 
          iprot.readListEnd()
6494 
        else:
6495 
          iprot.skip(ftype)
6496 
      elif fid == 1:
6497 
        if ftype == TType.STRUCT:
6498 
          self.cex = CatalogServiceException()
6499 
          self.cex.read(iprot)
6500 
        else:
6501 
          iprot.skip(ftype)
6502 
      else:
6503 
        iprot.skip(ftype)
6504 
      iprot.readFieldEnd()
6505 
    iprot.readStructEnd()
6506 
 
6507 
  def write(self, oprot):
6508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6510 
      return
6511 
    oprot.writeStructBegin('getAllItems_result')
6512 
    if self.success is not None:
6513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6515 
      for iter36 in self.success:
6516 
        iter36.write(oprot)
6517 
      oprot.writeListEnd()
6518 
      oprot.writeFieldEnd()
6519 
    if self.cex is not None:
6520 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6521 
      self.cex.write(oprot)
6522 
      oprot.writeFieldEnd()
6523 
    oprot.writeFieldStop()
6524 
    oprot.writeStructEnd()
6525 
 
6526 
  def validate(self):
6527 
    return
6528 
 
6529 
 
6530 
  def __repr__(self):
6531 
    L = ['%s=%r' % (key, value)
6532 
      for key, value in self.__dict__.iteritems()]
6533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6534 
 
6535 
  def __eq__(self, other):
6536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6537 
 
6538 
  def __ne__(self, other):
6539 
    return not (self == other)
6540 
 
6541 
class getAllItemsByStatus_args:
6542 
  """
6543 
  Attributes:
6544 
   - itemStatus
6545 
  """
6546 
 
6547 
  thrift_spec = (
6548 
    None, # 0
6549 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6550 
  )
6551 
 
6552 
  def __init__(self, itemStatus=None,):
6553 
    self.itemStatus = itemStatus
6554 
 
6555 
  def read(self, iprot):
6556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6558 
      return
6559 
    iprot.readStructBegin()
6560 
    while True:
6561 
      (fname, ftype, fid) = iprot.readFieldBegin()
6562 
      if ftype == TType.STOP:
6563 
        break
6564 
      if fid == 1:
6565 
        if ftype == TType.I32:
6566 
          self.itemStatus = iprot.readI32();
6567 
        else:
6568 
          iprot.skip(ftype)
6569 
      else:
6570 
        iprot.skip(ftype)
6571 
      iprot.readFieldEnd()
6572 
    iprot.readStructEnd()
6573 
 
6574 
  def write(self, oprot):
6575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6577 
      return
6578 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6579 
    if self.itemStatus is not None:
6580 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6581 
      oprot.writeI32(self.itemStatus)
6582 
      oprot.writeFieldEnd()
6583 
    oprot.writeFieldStop()
6584 
    oprot.writeStructEnd()
6585 
 
6586 
  def validate(self):
6587 
    return
6588 
 
6589 
 
6590 
  def __repr__(self):
6591 
    L = ['%s=%r' % (key, value)
6592 
      for key, value in self.__dict__.iteritems()]
6593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6594 
 
6595 
  def __eq__(self, other):
6596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6597 
 
6598 
  def __ne__(self, other):
6599 
    return not (self == other)
6600 
 
6601 
class getAllItemsByStatus_result:
6602 
  """
6603 
  Attributes:
6604 
   - success
6605 
   - cex
6606 
  """
6607 
 
6608 
  thrift_spec = (
6609 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6610 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6611 
  )
6612 
 
6613 
  def __init__(self, success=None, cex=None,):
6614 
    self.success = success
6615 
    self.cex = cex
6616 
 
6617 
  def read(self, iprot):
6618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6620 
      return
6621 
    iprot.readStructBegin()
6622 
    while True:
6623 
      (fname, ftype, fid) = iprot.readFieldBegin()
6624 
      if ftype == TType.STOP:
6625 
        break
6626 
      if fid == 0:
6627 
        if ftype == TType.LIST:
6628 
          self.success = []
6629 
          (_etype40, _size37) = iprot.readListBegin()
6630 
          for _i41 in xrange(_size37):
6631 
            _elem42 = Item()
6632 
            _elem42.read(iprot)
6633 
            self.success.append(_elem42)
6634 
          iprot.readListEnd()
6635 
        else:
6636 
          iprot.skip(ftype)
6637 
      elif fid == 1:
6638 
        if ftype == TType.STRUCT:
6639 
          self.cex = CatalogServiceException()
6640 
          self.cex.read(iprot)
6641 
        else:
6642 
          iprot.skip(ftype)
6643 
      else:
6644 
        iprot.skip(ftype)
6645 
      iprot.readFieldEnd()
6646 
    iprot.readStructEnd()
6647 
 
6648 
  def write(self, oprot):
6649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6651 
      return
6652 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6653 
    if self.success is not None:
6654 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6655 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6656 
      for iter43 in self.success:
6657 
        iter43.write(oprot)
6658 
      oprot.writeListEnd()
6659 
      oprot.writeFieldEnd()
6660 
    if self.cex is not None:
6661 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6662 
      self.cex.write(oprot)
6663 
      oprot.writeFieldEnd()
6664 
    oprot.writeFieldStop()
6665 
    oprot.writeStructEnd()
6666 
 
6667 
  def validate(self):
6668 
    return
6669 
 
6670 
 
6671 
  def __repr__(self):
6672 
    L = ['%s=%r' % (key, value)
6673 
      for key, value in self.__dict__.iteritems()]
6674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6675 
 
6676 
  def __eq__(self, other):
6677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6678 
 
6679 
  def __ne__(self, other):
6680 
    return not (self == other)
6681 
 
6682 
class markItemAsContentComplete_args:
6683 
  """
6684 
  Attributes:
6685 
   - entityId
6686 
   - category
6687 
   - brand
6688 
   - modelName
6689 
   - modelNumber
6690 
  """
6691 
 
6692 
  thrift_spec = (
6693 
    None, # 0
6694 
    (1, TType.I64, 'entityId', None, None, ), # 1
6695 
    (2, TType.I64, 'category', None, None, ), # 2
6696 
    (3, TType.STRING, 'brand', None, None, ), # 3
6697 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6698 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6699 
  )
6700 
 
6701 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6702 
    self.entityId = entityId
6703 
    self.category = category
6704 
    self.brand = brand
6705 
    self.modelName = modelName
6706 
    self.modelNumber = modelNumber
6707 
 
6708 
  def read(self, iprot):
6709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6711 
      return
6712 
    iprot.readStructBegin()
6713 
    while True:
6714 
      (fname, ftype, fid) = iprot.readFieldBegin()
6715 
      if ftype == TType.STOP:
6716 
        break
6717 
      if fid == 1:
6718 
        if ftype == TType.I64:
6719 
          self.entityId = iprot.readI64();
6720 
        else:
6721 
          iprot.skip(ftype)
6722 
      elif fid == 2:
6723 
        if ftype == TType.I64:
6724 
          self.category = iprot.readI64();
6725 
        else:
6726 
          iprot.skip(ftype)
6727 
      elif fid == 3:
6728 
        if ftype == TType.STRING:
6729 
          self.brand = iprot.readString();
6730 
        else:
6731 
          iprot.skip(ftype)
6732 
      elif fid == 4:
6733 
        if ftype == TType.STRING:
6734 
          self.modelName = iprot.readString();
6735 
        else:
6736 
          iprot.skip(ftype)
6737 
      elif fid == 5:
6738 
        if ftype == TType.STRING:
6739 
          self.modelNumber = iprot.readString();
6740 
        else:
6741 
          iprot.skip(ftype)
6742 
      else:
6743 
        iprot.skip(ftype)
6744 
      iprot.readFieldEnd()
6745 
    iprot.readStructEnd()
6746 
 
6747 
  def write(self, oprot):
6748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6750 
      return
6751 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6752 
    if self.entityId is not None:
6753 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6754 
      oprot.writeI64(self.entityId)
6755 
      oprot.writeFieldEnd()
6756 
    if self.category is not None:
6757 
      oprot.writeFieldBegin('category', TType.I64, 2)
6758 
      oprot.writeI64(self.category)
6759 
      oprot.writeFieldEnd()
6760 
    if self.brand is not None:
6761 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6762 
      oprot.writeString(self.brand)
6763 
      oprot.writeFieldEnd()
6764 
    if self.modelName is not None:
6765 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6766 
      oprot.writeString(self.modelName)
6767 
      oprot.writeFieldEnd()
6768 
    if self.modelNumber is not None:
6769 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6770 
      oprot.writeString(self.modelNumber)
6771 
      oprot.writeFieldEnd()
6772 
    oprot.writeFieldStop()
6773 
    oprot.writeStructEnd()
6774 
 
6775 
  def validate(self):
6776 
    return
6777 
 
6778 
 
6779 
  def __repr__(self):
6780 
    L = ['%s=%r' % (key, value)
6781 
      for key, value in self.__dict__.iteritems()]
6782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6783 
 
6784 
  def __eq__(self, other):
6785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6786 
 
6787 
  def __ne__(self, other):
6788 
    return not (self == other)
6789 
 
6790 
class markItemAsContentComplete_result:
6791 
  """
6792 
  Attributes:
6793 
   - success
6794 
   - cex
6795 
  """
6796 
 
6797 
  thrift_spec = (
6798 
    (0, TType.BOOL, 'success', None, None, ), # 0
6799 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6800 
  )
6801 
 
6802 
  def __init__(self, success=None, cex=None,):
6803 
    self.success = success
6804 
    self.cex = cex
6805 
 
6806 
  def read(self, iprot):
6807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6809 
      return
6810 
    iprot.readStructBegin()
6811 
    while True:
6812 
      (fname, ftype, fid) = iprot.readFieldBegin()
6813 
      if ftype == TType.STOP:
6814 
        break
6815 
      if fid == 0:
6816 
        if ftype == TType.BOOL:
6817 
          self.success = iprot.readBool();
6818 
        else:
6819 
          iprot.skip(ftype)
6820 
      elif fid == 1:
6821 
        if ftype == TType.STRUCT:
6822 
          self.cex = CatalogServiceException()
6823 
          self.cex.read(iprot)
6824 
        else:
6825 
          iprot.skip(ftype)
6826 
      else:
6827 
        iprot.skip(ftype)
6828 
      iprot.readFieldEnd()
6829 
    iprot.readStructEnd()
6830 
 
6831 
  def write(self, oprot):
6832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6834 
      return
6835 
    oprot.writeStructBegin('markItemAsContentComplete_result')
6836 
    if self.success is not None:
6837 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6838 
      oprot.writeBool(self.success)
6839 
      oprot.writeFieldEnd()
6840 
    if self.cex is not None:
6841 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6842 
      self.cex.write(oprot)
6843 
      oprot.writeFieldEnd()
6844 
    oprot.writeFieldStop()
6845 
    oprot.writeStructEnd()
6846 
 
6847 
  def validate(self):
6848 
    return
6849 
 
6850 
 
6851 
  def __repr__(self):
6852 
    L = ['%s=%r' % (key, value)
6853 
      for key, value in self.__dict__.iteritems()]
6854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6855 
 
6856 
  def __eq__(self, other):
6857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6858 
 
6859 
  def __ne__(self, other):
6860 
    return not (self == other)
6861 
 
6862 
class getAllItemsInRange_args:
6863 
  """
6864 
  Attributes:
6865 
   - offset
6866 
   - limit
6867 
  """
6868 
 
6869 
  thrift_spec = (
6870 
    None, # 0
6871 
    (1, TType.I64, 'offset', None, None, ), # 1
6872 
    (2, TType.I64, 'limit', None, None, ), # 2
6873 
  )
6874 
 
6875 
  def __init__(self, offset=None, limit=None,):
6876 
    self.offset = offset
6877 
    self.limit = limit
6878 
 
6879 
  def read(self, iprot):
6880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6882 
      return
6883 
    iprot.readStructBegin()
6884 
    while True:
6885 
      (fname, ftype, fid) = iprot.readFieldBegin()
6886 
      if ftype == TType.STOP:
6887 
        break
6888 
      if fid == 1:
6889 
        if ftype == TType.I64:
6890 
          self.offset = iprot.readI64();
6891 
        else:
6892 
          iprot.skip(ftype)
6893 
      elif fid == 2:
6894 
        if ftype == TType.I64:
6895 
          self.limit = iprot.readI64();
6896 
        else:
6897 
          iprot.skip(ftype)
6898 
      else:
6899 
        iprot.skip(ftype)
6900 
      iprot.readFieldEnd()
6901 
    iprot.readStructEnd()
6902 
 
6903 
  def write(self, oprot):
6904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6906 
      return
6907 
    oprot.writeStructBegin('getAllItemsInRange_args')
6908 
    if self.offset is not None:
6909 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6910 
      oprot.writeI64(self.offset)
6911 
      oprot.writeFieldEnd()
6912 
    if self.limit is not None:
6913 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6914 
      oprot.writeI64(self.limit)
6915 
      oprot.writeFieldEnd()
6916 
    oprot.writeFieldStop()
6917 
    oprot.writeStructEnd()
6918 
 
6919 
  def validate(self):
6920 
    return
6921 
 
6922 
 
6923 
  def __repr__(self):
6924 
    L = ['%s=%r' % (key, value)
6925 
      for key, value in self.__dict__.iteritems()]
6926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6927 
 
6928 
  def __eq__(self, other):
6929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6930 
 
6931 
  def __ne__(self, other):
6932 
    return not (self == other)
6933 
 
6934 
class getAllItemsInRange_result:
6935 
  """
6936 
  Attributes:
6937 
   - success
6938 
   - cex
6939 
  """
6940 
 
6941 
  thrift_spec = (
6942 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6943 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6944 
  )
6945 
 
6946 
  def __init__(self, success=None, cex=None,):
6947 
    self.success = success
6948 
    self.cex = cex
6949 
 
6950 
  def read(self, iprot):
6951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6953 
      return
6954 
    iprot.readStructBegin()
6955 
    while True:
6956 
      (fname, ftype, fid) = iprot.readFieldBegin()
6957 
      if ftype == TType.STOP:
6958 
        break
6959 
      if fid == 0:
6960 
        if ftype == TType.LIST:
6961 
          self.success = []
6962 
          (_etype47, _size44) = iprot.readListBegin()
6963 
          for _i48 in xrange(_size44):
6964 
            _elem49 = Item()
6965 
            _elem49.read(iprot)
6966 
            self.success.append(_elem49)
6967 
          iprot.readListEnd()
6968 
        else:
6969 
          iprot.skip(ftype)
6970 
      elif fid == 1:
6971 
        if ftype == TType.STRUCT:
6972 
          self.cex = CatalogServiceException()
6973 
          self.cex.read(iprot)
6974 
        else:
6975 
          iprot.skip(ftype)
6976 
      else:
6977 
        iprot.skip(ftype)
6978 
      iprot.readFieldEnd()
6979 
    iprot.readStructEnd()
6980 
 
6981 
  def write(self, oprot):
6982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6984 
      return
6985 
    oprot.writeStructBegin('getAllItemsInRange_result')
6986 
    if self.success is not None:
6987 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6988 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6989 
      for iter50 in self.success:
6990 
        iter50.write(oprot)
6991 
      oprot.writeListEnd()
6992 
      oprot.writeFieldEnd()
6993 
    if self.cex is not None:
6994 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6995 
      self.cex.write(oprot)
6996 
      oprot.writeFieldEnd()
6997 
    oprot.writeFieldStop()
6998 
    oprot.writeStructEnd()
6999 
 
7000 
  def validate(self):
7001 
    return
7002 
 
7003 
 
7004 
  def __repr__(self):
7005 
    L = ['%s=%r' % (key, value)
7006 
      for key, value in self.__dict__.iteritems()]
7007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7008 
 
7009 
  def __eq__(self, other):
7010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7011 
 
7012 
  def __ne__(self, other):
7013 
    return not (self == other)
7014 
 
7015 
class getAllItemsByStatusInRange_args:
7016 
  """
7017 
  Attributes:
7018 
   - itemStatus
7019 
   - offset
7020 
   - limit
7021 
  """
7022 
 
7023 
  thrift_spec = (
7024 
    None, # 0
7025 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7026 
    (2, TType.I64, 'offset', None, None, ), # 2
7027 
    (3, TType.I64, 'limit', None, None, ), # 3
7028 
  )
7029 
 
7030 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7031 
    self.itemStatus = itemStatus
7032 
    self.offset = offset
7033 
    self.limit = limit
7034 
 
7035 
  def read(self, iprot):
7036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7038 
      return
7039 
    iprot.readStructBegin()
7040 
    while True:
7041 
      (fname, ftype, fid) = iprot.readFieldBegin()
7042 
      if ftype == TType.STOP:
7043 
        break
7044 
      if fid == 1:
7045 
        if ftype == TType.I32:
7046 
          self.itemStatus = iprot.readI32();
7047 
        else:
7048 
          iprot.skip(ftype)
7049 
      elif fid == 2:
7050 
        if ftype == TType.I64:
7051 
          self.offset = iprot.readI64();
7052 
        else:
7053 
          iprot.skip(ftype)
7054 
      elif fid == 3:
7055 
        if ftype == TType.I64:
7056 
          self.limit = iprot.readI64();
7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      else:
7060 
        iprot.skip(ftype)
7061 
      iprot.readFieldEnd()
7062 
    iprot.readStructEnd()
7063 
 
7064 
  def write(self, oprot):
7065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7067 
      return
7068 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7069 
    if self.itemStatus is not None:
7070 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7071 
      oprot.writeI32(self.itemStatus)
7072 
      oprot.writeFieldEnd()
7073 
    if self.offset is not None:
7074 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7075 
      oprot.writeI64(self.offset)
7076 
      oprot.writeFieldEnd()
7077 
    if self.limit is not None:
7078 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7079 
      oprot.writeI64(self.limit)
7080 
      oprot.writeFieldEnd()
7081 
    oprot.writeFieldStop()
7082 
    oprot.writeStructEnd()
7083 
 
7084 
  def validate(self):
7085 
    return
7086 
 
7087 
 
7088 
  def __repr__(self):
7089 
    L = ['%s=%r' % (key, value)
7090 
      for key, value in self.__dict__.iteritems()]
7091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7092 
 
7093 
  def __eq__(self, other):
7094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7095 
 
7096 
  def __ne__(self, other):
7097 
    return not (self == other)
7098 
 
7099 
class getAllItemsByStatusInRange_result:
7100 
  """
7101 
  Attributes:
7102 
   - success
7103 
   - cex
7104 
  """
7105 
 
7106 
  thrift_spec = (
7107 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7108 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7109 
  )
7110 
 
7111 
  def __init__(self, success=None, cex=None,):
7112 
    self.success = success
7113 
    self.cex = cex
7114 
 
7115 
  def read(self, iprot):
7116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7118 
      return
7119 
    iprot.readStructBegin()
7120 
    while True:
7121 
      (fname, ftype, fid) = iprot.readFieldBegin()
7122 
      if ftype == TType.STOP:
7123 
        break
7124 
      if fid == 0:
7125 
        if ftype == TType.LIST:
7126 
          self.success = []
7127 
          (_etype54, _size51) = iprot.readListBegin()
7128 
          for _i55 in xrange(_size51):
7129 
            _elem56 = Item()
7130 
            _elem56.read(iprot)
7131 
            self.success.append(_elem56)
7132 
          iprot.readListEnd()
7133 
        else:
7134 
          iprot.skip(ftype)
7135 
      elif fid == 1:
7136 
        if ftype == TType.STRUCT:
7137 
          self.cex = CatalogServiceException()
7138 
          self.cex.read(iprot)
7139 
        else:
7140 
          iprot.skip(ftype)
7141 
      else:
7142 
        iprot.skip(ftype)
7143 
      iprot.readFieldEnd()
7144 
    iprot.readStructEnd()
7145 
 
7146 
  def write(self, oprot):
7147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7149 
      return
7150 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7151 
    if self.success is not None:
7152 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7153 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7154 
      for iter57 in self.success:
7155 
        iter57.write(oprot)
7156 
      oprot.writeListEnd()
7157 
      oprot.writeFieldEnd()
7158 
    if self.cex is not None:
7159 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7160 
      self.cex.write(oprot)
7161 
      oprot.writeFieldEnd()
7162 
    oprot.writeFieldStop()
7163 
    oprot.writeStructEnd()
7164 
 
7165 
  def validate(self):
7166 
    return
7167 
 
7168 
 
7169 
  def __repr__(self):
7170 
    L = ['%s=%r' % (key, value)
7171 
      for key, value in self.__dict__.iteritems()]
7172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7173 
 
7174 
  def __eq__(self, other):
7175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7176 
 
7177 
  def __ne__(self, other):
7178 
    return not (self == other)
7179 
 
7180 
class getItemCountByStatus_args:
7181 
  """
7182 
  Attributes:
7183 
   - useStatus
7184 
   - itemStatus
7185 
  """
7186 
 
7187 
  thrift_spec = (
7188 
    None, # 0
7189 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7190 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7191 
  )
7192 
 
7193 
  def __init__(self, useStatus=None, itemStatus=None,):
7194 
    self.useStatus = useStatus
7195 
    self.itemStatus = itemStatus
7196 
 
7197 
  def read(self, iprot):
7198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7200 
      return
7201 
    iprot.readStructBegin()
7202 
    while True:
7203 
      (fname, ftype, fid) = iprot.readFieldBegin()
7204 
      if ftype == TType.STOP:
7205 
        break
7206 
      if fid == 1:
7207 
        if ftype == TType.BOOL:
7208 
          self.useStatus = iprot.readBool();
7209 
        else:
7210 
          iprot.skip(ftype)
7211 
      elif fid == 2:
7212 
        if ftype == TType.I32:
7213 
          self.itemStatus = iprot.readI32();
7214 
        else:
7215 
          iprot.skip(ftype)
7216 
      else:
7217 
        iprot.skip(ftype)
7218 
      iprot.readFieldEnd()
7219 
    iprot.readStructEnd()
7220 
 
7221 
  def write(self, oprot):
7222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7224 
      return
7225 
    oprot.writeStructBegin('getItemCountByStatus_args')
7226 
    if self.useStatus is not None:
7227 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7228 
      oprot.writeBool(self.useStatus)
7229 
      oprot.writeFieldEnd()
7230 
    if self.itemStatus is not None:
7231 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7232 
      oprot.writeI32(self.itemStatus)
7233 
      oprot.writeFieldEnd()
7234 
    oprot.writeFieldStop()
7235 
    oprot.writeStructEnd()
7236 
 
7237 
  def validate(self):
7238 
    return
7239 
 
7240 
 
7241 
  def __repr__(self):
7242 
    L = ['%s=%r' % (key, value)
7243 
      for key, value in self.__dict__.iteritems()]
7244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7245 
 
7246 
  def __eq__(self, other):
7247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7248 
 
7249 
  def __ne__(self, other):
7250 
    return not (self == other)
7251 
 
7252 
class getItemCountByStatus_result:
7253 
  """
7254 
  Attributes:
7255 
   - success
7256 
  """
7257 
 
7258 
  thrift_spec = (
7259 
    (0, TType.I32, 'success', None, None, ), # 0
7260 
  )
7261 
 
7262 
  def __init__(self, success=None,):
7263 
    self.success = success
7264 
 
7265 
  def read(self, iprot):
7266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7268 
      return
7269 
    iprot.readStructBegin()
7270 
    while True:
7271 
      (fname, ftype, fid) = iprot.readFieldBegin()
7272 
      if ftype == TType.STOP:
7273 
        break
7274 
      if fid == 0:
7275 
        if ftype == TType.I32:
7276 
          self.success = iprot.readI32();
7277 
        else:
7278 
          iprot.skip(ftype)
7279 
      else:
7280 
        iprot.skip(ftype)
7281 
      iprot.readFieldEnd()
7282 
    iprot.readStructEnd()
7283 
 
7284 
  def write(self, oprot):
7285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7287 
      return
7288 
    oprot.writeStructBegin('getItemCountByStatus_result')
7289 
    if self.success is not None:
7290 
      oprot.writeFieldBegin('success', TType.I32, 0)
7291 
      oprot.writeI32(self.success)
7292 
      oprot.writeFieldEnd()
7293 
    oprot.writeFieldStop()
7294 
    oprot.writeStructEnd()
7295 
 
7296 
  def validate(self):
7297 
    return
7298 
 
7299 
 
7300 
  def __repr__(self):
7301 
    L = ['%s=%r' % (key, value)
7302 
      for key, value in self.__dict__.iteritems()]
7303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7304 
 
7305 
  def __eq__(self, other):
7306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7307 
 
7308 
  def __ne__(self, other):
7309 
    return not (self == other)
7310 
 
7311 
class getBestSellers_args:
7312 
 
7313 
  thrift_spec = (
7314 
  )
7315 
 
7316 
  def read(self, iprot):
7317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7319 
      return
7320 
    iprot.readStructBegin()
7321 
    while True:
7322 
      (fname, ftype, fid) = iprot.readFieldBegin()
7323 
      if ftype == TType.STOP:
7324 
        break
7325 
      else:
7326 
        iprot.skip(ftype)
7327 
      iprot.readFieldEnd()
7328 
    iprot.readStructEnd()
7329 
 
7330 
  def write(self, oprot):
7331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7333 
      return
7334 
    oprot.writeStructBegin('getBestSellers_args')
7335 
    oprot.writeFieldStop()
7336 
    oprot.writeStructEnd()
7337 
 
7338 
  def validate(self):
7339 
    return
7340 
 
7341 
 
7342 
  def __repr__(self):
7343 
    L = ['%s=%r' % (key, value)
7344 
      for key, value in self.__dict__.iteritems()]
7345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7346 
 
7347 
  def __eq__(self, other):
7348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7349 
 
7350 
  def __ne__(self, other):
7351 
    return not (self == other)
7352 
 
7353 
class getBestSellers_result:
7354 
  """
7355 
  Attributes:
7356 
   - success
7357 
   - isex
7358 
  """
7359 
 
7360 
  thrift_spec = (
7361 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7362 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7363 
  )
7364 
 
7365 
  def __init__(self, success=None, isex=None,):
7366 
    self.success = success
7367 
    self.isex = isex
7368 
 
7369 
  def read(self, iprot):
7370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7372 
      return
7373 
    iprot.readStructBegin()
7374 
    while True:
7375 
      (fname, ftype, fid) = iprot.readFieldBegin()
7376 
      if ftype == TType.STOP:
7377 
        break
7378 
      if fid == 0:
7379 
        if ftype == TType.LIST:
7380 
          self.success = []
7381 
          (_etype61, _size58) = iprot.readListBegin()
7382 
          for _i62 in xrange(_size58):
7383 
            _elem63 = Item()
7384 
            _elem63.read(iprot)
7385 
            self.success.append(_elem63)
7386 
          iprot.readListEnd()
7387 
        else:
7388 
          iprot.skip(ftype)
7389 
      elif fid == 1:
7390 
        if ftype == TType.STRUCT:
7391 
          self.isex = CatalogServiceException()
7392 
          self.isex.read(iprot)
7393 
        else:
7394 
          iprot.skip(ftype)
7395 
      else:
7396 
        iprot.skip(ftype)
7397 
      iprot.readFieldEnd()
7398 
    iprot.readStructEnd()
7399 
 
7400 
  def write(self, oprot):
7401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7403 
      return
7404 
    oprot.writeStructBegin('getBestSellers_result')
7405 
    if self.success is not None:
7406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7408 
      for iter64 in self.success:
7409 
        iter64.write(oprot)
7410 
      oprot.writeListEnd()
7411 
      oprot.writeFieldEnd()
7412 
    if self.isex is not None:
7413 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7414 
      self.isex.write(oprot)
7415 
      oprot.writeFieldEnd()
7416 
    oprot.writeFieldStop()
7417 
    oprot.writeStructEnd()
7418 
 
7419 
  def validate(self):
7420 
    return
7421 
 
7422 
 
7423 
  def __repr__(self):
7424 
    L = ['%s=%r' % (key, value)
7425 
      for key, value in self.__dict__.iteritems()]
7426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7427 
 
7428 
  def __eq__(self, other):
7429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7430 
 
7431 
  def __ne__(self, other):
7432 
    return not (self == other)
7433 
 
7434 
class getBestSellersCatalogIds_args:
7435 
  """
7436 
  Attributes:
7437 
   - beginIndex
7438 
   - totalItems
7439 
   - brand
7440 
   - category
7441 
  """
7442 
 
7443 
  thrift_spec = (
7444 
    None, # 0
7445 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7446 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7447 
    (3, TType.STRING, 'brand', None, None, ), # 3
7448 
    (4, TType.I64, 'category', None, None, ), # 4
7449 
  )
7450 
 
7451 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7452 
    self.beginIndex = beginIndex
7453 
    self.totalItems = totalItems
7454 
    self.brand = brand
7455 
    self.category = category
7456 
 
7457 
  def read(self, iprot):
7458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7460 
      return
7461 
    iprot.readStructBegin()
7462 
    while True:
7463 
      (fname, ftype, fid) = iprot.readFieldBegin()
7464 
      if ftype == TType.STOP:
7465 
        break
7466 
      if fid == 1:
7467 
        if ftype == TType.I64:
7468 
          self.beginIndex = iprot.readI64();
7469 
        else:
7470 
          iprot.skip(ftype)
7471 
      elif fid == 2:
7472 
        if ftype == TType.I64:
7473 
          self.totalItems = iprot.readI64();
7474 
        else:
7475 
          iprot.skip(ftype)
7476 
      elif fid == 3:
7477 
        if ftype == TType.STRING:
7478 
          self.brand = iprot.readString();
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 4:
7482 
        if ftype == TType.I64:
7483 
          self.category = iprot.readI64();
7484 
        else:
7485 
          iprot.skip(ftype)
7486 
      else:
7487 
        iprot.skip(ftype)
7488 
      iprot.readFieldEnd()
7489 
    iprot.readStructEnd()
7490 
 
7491 
  def write(self, oprot):
7492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7494 
      return
7495 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7496 
    if self.beginIndex is not None:
7497 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7498 
      oprot.writeI64(self.beginIndex)
7499 
      oprot.writeFieldEnd()
7500 
    if self.totalItems is not None:
7501 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7502 
      oprot.writeI64(self.totalItems)
7503 
      oprot.writeFieldEnd()
7504 
    if self.brand is not None:
7505 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7506 
      oprot.writeString(self.brand)
7507 
      oprot.writeFieldEnd()
7508 
    if self.category is not None:
7509 
      oprot.writeFieldBegin('category', TType.I64, 4)
7510 
      oprot.writeI64(self.category)
7511 
      oprot.writeFieldEnd()
7512 
    oprot.writeFieldStop()
7513 
    oprot.writeStructEnd()
7514 
 
7515 
  def validate(self):
7516 
    return
7517 
 
7518 
 
7519 
  def __repr__(self):
7520 
    L = ['%s=%r' % (key, value)
7521 
      for key, value in self.__dict__.iteritems()]
7522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7523 
 
7524 
  def __eq__(self, other):
7525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7526 
 
7527 
  def __ne__(self, other):
7528 
    return not (self == other)
7529 
 
7530 
class getBestSellersCatalogIds_result:
7531 
  """
7532 
  Attributes:
7533 
   - success
7534 
   - cex
7535 
  """
7536 
 
7537 
  thrift_spec = (
7538 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7539 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7540 
  )
7541 
 
7542 
  def __init__(self, success=None, cex=None,):
7543 
    self.success = success
7544 
    self.cex = cex
7545 
 
7546 
  def read(self, iprot):
7547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7549 
      return
7550 
    iprot.readStructBegin()
7551 
    while True:
7552 
      (fname, ftype, fid) = iprot.readFieldBegin()
7553 
      if ftype == TType.STOP:
7554 
        break
7555 
      if fid == 0:
7556 
        if ftype == TType.LIST:
7557 
          self.success = []
7558 
          (_etype68, _size65) = iprot.readListBegin()
7559 
          for _i69 in xrange(_size65):
7560 
            _elem70 = iprot.readI64();
7561 
            self.success.append(_elem70)
7562 
          iprot.readListEnd()
7563 
        else:
7564 
          iprot.skip(ftype)
7565 
      elif fid == 1:
7566 
        if ftype == TType.STRUCT:
7567 
          self.cex = CatalogServiceException()
7568 
          self.cex.read(iprot)
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      else:
7572 
        iprot.skip(ftype)
7573 
      iprot.readFieldEnd()
7574 
    iprot.readStructEnd()
7575 
 
7576 
  def write(self, oprot):
7577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7579 
      return
7580 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7581 
    if self.success is not None:
7582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7583 
      oprot.writeListBegin(TType.I64, len(self.success))
7584 
      for iter71 in self.success:
7585 
        oprot.writeI64(iter71)
7586 
      oprot.writeListEnd()
7587 
      oprot.writeFieldEnd()
7588 
    if self.cex is not None:
7589 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7590 
      self.cex.write(oprot)
7591 
      oprot.writeFieldEnd()
7592 
    oprot.writeFieldStop()
7593 
    oprot.writeStructEnd()
7594 
 
7595 
  def validate(self):
7596 
    return
7597 
 
7598 
 
7599 
  def __repr__(self):
7600 
    L = ['%s=%r' % (key, value)
7601 
      for key, value in self.__dict__.iteritems()]
7602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7603 
 
7604 
  def __eq__(self, other):
7605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7606 
 
7607 
  def __ne__(self, other):
7608 
    return not (self == other)
7609 
 
7610 
class getBestSellersCount_args:
7611 
 
7612 
  thrift_spec = (
7613 
  )
7614 
 
7615 
  def read(self, iprot):
7616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7618 
      return
7619 
    iprot.readStructBegin()
7620 
    while True:
7621 
      (fname, ftype, fid) = iprot.readFieldBegin()
7622 
      if ftype == TType.STOP:
7623 
        break
7624 
      else:
7625 
        iprot.skip(ftype)
7626 
      iprot.readFieldEnd()
7627 
    iprot.readStructEnd()
7628 
 
7629 
  def write(self, oprot):
7630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7632 
      return
7633 
    oprot.writeStructBegin('getBestSellersCount_args')
7634 
    oprot.writeFieldStop()
7635 
    oprot.writeStructEnd()
7636 
 
7637 
  def validate(self):
7638 
    return
7639 
 
7640 
 
7641 
  def __repr__(self):
7642 
    L = ['%s=%r' % (key, value)
7643 
      for key, value in self.__dict__.iteritems()]
7644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7645 
 
7646 
  def __eq__(self, other):
7647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7648 
 
7649 
  def __ne__(self, other):
7650 
    return not (self == other)
7651 
 
7652 
class getBestSellersCount_result:
7653 
  """
7654 
  Attributes:
7655 
   - success
7656 
   - cex
7657 
  """
7658 
 
7659 
  thrift_spec = (
7660 
    (0, TType.I64, 'success', None, None, ), # 0
7661 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7662 
  )
7663 
 
7664 
  def __init__(self, success=None, cex=None,):
7665 
    self.success = success
7666 
    self.cex = cex
7667 
 
7668 
  def read(self, iprot):
7669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7671 
      return
7672 
    iprot.readStructBegin()
7673 
    while True:
7674 
      (fname, ftype, fid) = iprot.readFieldBegin()
7675 
      if ftype == TType.STOP:
7676 
        break
7677 
      if fid == 0:
7678 
        if ftype == TType.I64:
7679 
          self.success = iprot.readI64();
7680 
        else:
7681 
          iprot.skip(ftype)
7682 
      elif fid == 1:
7683 
        if ftype == TType.STRUCT:
7684 
          self.cex = CatalogServiceException()
7685 
          self.cex.read(iprot)
7686 
        else:
7687 
          iprot.skip(ftype)
7688 
      else:
7689 
        iprot.skip(ftype)
7690 
      iprot.readFieldEnd()
7691 
    iprot.readStructEnd()
7692 
 
7693 
  def write(self, oprot):
7694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7696 
      return
7697 
    oprot.writeStructBegin('getBestSellersCount_result')
7698 
    if self.success is not None:
7699 
      oprot.writeFieldBegin('success', TType.I64, 0)
7700 
      oprot.writeI64(self.success)
7701 
      oprot.writeFieldEnd()
7702 
    if self.cex is not None:
7703 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7704 
      self.cex.write(oprot)
7705 
      oprot.writeFieldEnd()
7706 
    oprot.writeFieldStop()
7707 
    oprot.writeStructEnd()
7708 
 
7709 
  def validate(self):
7710 
    return
7711 
 
7712 
 
7713 
  def __repr__(self):
7714 
    L = ['%s=%r' % (key, value)
7715 
      for key, value in self.__dict__.iteritems()]
7716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7717 
 
7718 
  def __eq__(self, other):
7719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7720 
 
7721 
  def __ne__(self, other):
7722 
    return not (self == other)
7723 
 
7724 
class getBestDeals_args:
7725 
 
7726 
  thrift_spec = (
7727 
  )
7728 
 
7729 
  def read(self, iprot):
7730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7732 
      return
7733 
    iprot.readStructBegin()
7734 
    while True:
7735 
      (fname, ftype, fid) = iprot.readFieldBegin()
7736 
      if ftype == TType.STOP:
7737 
        break
7738 
      else:
7739 
        iprot.skip(ftype)
7740 
      iprot.readFieldEnd()
7741 
    iprot.readStructEnd()
7742 
 
7743 
  def write(self, oprot):
7744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7746 
      return
7747 
    oprot.writeStructBegin('getBestDeals_args')
7748 
    oprot.writeFieldStop()
7749 
    oprot.writeStructEnd()
7750 
 
7751 
  def validate(self):
7752 
    return
7753 
 
7754 
 
7755 
  def __repr__(self):
7756 
    L = ['%s=%r' % (key, value)
7757 
      for key, value in self.__dict__.iteritems()]
7758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7759 
 
7760 
  def __eq__(self, other):
7761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7762 
 
7763 
  def __ne__(self, other):
7764 
    return not (self == other)
7765 
 
7766 
class getBestDeals_result:
7767 
  """
7768 
  Attributes:
7769 
   - success
7770 
   - isex
7771 
  """
7772 
 
7773 
  thrift_spec = (
7774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7775 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7776 
  )
7777 
 
7778 
  def __init__(self, success=None, isex=None,):
7779 
    self.success = success
7780 
    self.isex = isex
7781 
 
7782 
  def read(self, iprot):
7783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7785 
      return
7786 
    iprot.readStructBegin()
7787 
    while True:
7788 
      (fname, ftype, fid) = iprot.readFieldBegin()
7789 
      if ftype == TType.STOP:
7790 
        break
7791 
      if fid == 0:
7792 
        if ftype == TType.LIST:
7793 
          self.success = []
7794 
          (_etype75, _size72) = iprot.readListBegin()
7795 
          for _i76 in xrange(_size72):
7796 
            _elem77 = Item()
7797 
            _elem77.read(iprot)
7798 
            self.success.append(_elem77)
7799 
          iprot.readListEnd()
7800 
        else:
7801 
          iprot.skip(ftype)
7802 
      elif fid == 1:
7803 
        if ftype == TType.STRUCT:
7804 
          self.isex = CatalogServiceException()
7805 
          self.isex.read(iprot)
7806 
        else:
7807 
          iprot.skip(ftype)
7808 
      else:
7809 
        iprot.skip(ftype)
7810 
      iprot.readFieldEnd()
7811 
    iprot.readStructEnd()
7812 
 
7813 
  def write(self, oprot):
7814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7816 
      return
7817 
    oprot.writeStructBegin('getBestDeals_result')
7818 
    if self.success is not None:
7819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7821 
      for iter78 in self.success:
7822 
        iter78.write(oprot)
7823 
      oprot.writeListEnd()
7824 
      oprot.writeFieldEnd()
7825 
    if self.isex is not None:
7826 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7827 
      self.isex.write(oprot)
7828 
      oprot.writeFieldEnd()
7829 
    oprot.writeFieldStop()
7830 
    oprot.writeStructEnd()
7831 
 
7832 
  def validate(self):
7833 
    return
7834 
 
7835 
 
7836 
  def __repr__(self):
7837 
    L = ['%s=%r' % (key, value)
7838 
      for key, value in self.__dict__.iteritems()]
7839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7840 
 
7841 
  def __eq__(self, other):
7842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7843 
 
7844 
  def __ne__(self, other):
7845 
    return not (self == other)
7846 
 
7847 
class getBestDealsCatalogIds_args:
7848 
  """
7849 
  Attributes:
7850 
   - beginIndex
7851 
   - totalItems
7852 
   - brand
7853 
   - category
7854 
  """
7855 
 
7856 
  thrift_spec = (
7857 
    None, # 0
7858 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7859 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7860 
    (3, TType.STRING, 'brand', None, None, ), # 3
7861 
    (4, TType.I64, 'category', None, None, ), # 4
7862 
  )
7863 
 
7864 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7865 
    self.beginIndex = beginIndex
7866 
    self.totalItems = totalItems
7867 
    self.brand = brand
7868 
    self.category = category
7869 
 
7870 
  def read(self, iprot):
7871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7873 
      return
7874 
    iprot.readStructBegin()
7875 
    while True:
7876 
      (fname, ftype, fid) = iprot.readFieldBegin()
7877 
      if ftype == TType.STOP:
7878 
        break
7879 
      if fid == 1:
7880 
        if ftype == TType.I64:
7881 
          self.beginIndex = iprot.readI64();
7882 
        else:
7883 
          iprot.skip(ftype)
7884 
      elif fid == 2:
7885 
        if ftype == TType.I64:
7886 
          self.totalItems = iprot.readI64();
7887 
        else:
7888 
          iprot.skip(ftype)
7889 
      elif fid == 3:
7890 
        if ftype == TType.STRING:
7891 
          self.brand = iprot.readString();
7892 
        else:
7893 
          iprot.skip(ftype)
7894 
      elif fid == 4:
7895 
        if ftype == TType.I64:
7896 
          self.category = iprot.readI64();
7897 
        else:
7898 
          iprot.skip(ftype)
7899 
      else:
7900 
        iprot.skip(ftype)
7901 
      iprot.readFieldEnd()
7902 
    iprot.readStructEnd()
7903 
 
7904 
  def write(self, oprot):
7905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7907 
      return
7908 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7909 
    if self.beginIndex is not None:
7910 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7911 
      oprot.writeI64(self.beginIndex)
7912 
      oprot.writeFieldEnd()
7913 
    if self.totalItems is not None:
7914 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7915 
      oprot.writeI64(self.totalItems)
7916 
      oprot.writeFieldEnd()
7917 
    if self.brand is not None:
7918 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7919 
      oprot.writeString(self.brand)
7920 
      oprot.writeFieldEnd()
7921 
    if self.category is not None:
7922 
      oprot.writeFieldBegin('category', TType.I64, 4)
7923 
      oprot.writeI64(self.category)
7924 
      oprot.writeFieldEnd()
7925 
    oprot.writeFieldStop()
7926 
    oprot.writeStructEnd()
7927 
 
7928 
  def validate(self):
7929 
    return
7930 
 
7931 
 
7932 
  def __repr__(self):
7933 
    L = ['%s=%r' % (key, value)
7934 
      for key, value in self.__dict__.iteritems()]
7935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7936 
 
7937 
  def __eq__(self, other):
7938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7939 
 
7940 
  def __ne__(self, other):
7941 
    return not (self == other)
7942 
 
7943 
class getBestDealsCatalogIds_result:
7944 
  """
7945 
  Attributes:
7946 
   - success
7947 
   - cex
7948 
  """
7949 
 
7950 
  thrift_spec = (
7951 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7952 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7953 
  )
7954 
 
7955 
  def __init__(self, success=None, cex=None,):
7956 
    self.success = success
7957 
    self.cex = cex
7958 
 
7959 
  def read(self, iprot):
7960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7962 
      return
7963 
    iprot.readStructBegin()
7964 
    while True:
7965 
      (fname, ftype, fid) = iprot.readFieldBegin()
7966 
      if ftype == TType.STOP:
7967 
        break
7968 
      if fid == 0:
7969 
        if ftype == TType.LIST:
7970 
          self.success = []
7971 
          (_etype82, _size79) = iprot.readListBegin()
7972 
          for _i83 in xrange(_size79):
7973 
            _elem84 = iprot.readI64();
7974 
            self.success.append(_elem84)
7975 
          iprot.readListEnd()
7976 
        else:
7977 
          iprot.skip(ftype)
7978 
      elif fid == 1:
7979 
        if ftype == TType.STRUCT:
7980 
          self.cex = CatalogServiceException()
7981 
          self.cex.read(iprot)
7982 
        else:
7983 
          iprot.skip(ftype)
7984 
      else:
7985 
        iprot.skip(ftype)
7986 
      iprot.readFieldEnd()
7987 
    iprot.readStructEnd()
7988 
 
7989 
  def write(self, oprot):
7990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7992 
      return
7993 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
7994 
    if self.success is not None:
7995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7996 
      oprot.writeListBegin(TType.I64, len(self.success))
7997 
      for iter85 in self.success:
7998 
        oprot.writeI64(iter85)
7999 
      oprot.writeListEnd()
8000 
      oprot.writeFieldEnd()
8001 
    if self.cex is not None:
8002 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8003 
      self.cex.write(oprot)
8004 
      oprot.writeFieldEnd()
8005 
    oprot.writeFieldStop()
8006 
    oprot.writeStructEnd()
8007 
 
8008 
  def validate(self):
8009 
    return
8010 
 
8011 
 
8012 
  def __repr__(self):
8013 
    L = ['%s=%r' % (key, value)
8014 
      for key, value in self.__dict__.iteritems()]
8015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8016 
 
8017 
  def __eq__(self, other):
8018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8019 
 
8020 
  def __ne__(self, other):
8021 
    return not (self == other)
8022 
 
8023 
class getBestDealsCount_args:
8024 
 
8025 
  thrift_spec = (
8026 
  )
8027 
 
8028 
  def read(self, iprot):
8029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8031 
      return
8032 
    iprot.readStructBegin()
8033 
    while True:
8034 
      (fname, ftype, fid) = iprot.readFieldBegin()
8035 
      if ftype == TType.STOP:
8036 
        break
8037 
      else:
8038 
        iprot.skip(ftype)
8039 
      iprot.readFieldEnd()
8040 
    iprot.readStructEnd()
8041 
 
8042 
  def write(self, oprot):
8043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8045 
      return
8046 
    oprot.writeStructBegin('getBestDealsCount_args')
8047 
    oprot.writeFieldStop()
8048 
    oprot.writeStructEnd()
8049 
 
8050 
  def validate(self):
8051 
    return
8052 
 
8053 
 
8054 
  def __repr__(self):
8055 
    L = ['%s=%r' % (key, value)
8056 
      for key, value in self.__dict__.iteritems()]
8057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8058 
 
8059 
  def __eq__(self, other):
8060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8061 
 
8062 
  def __ne__(self, other):
8063 
    return not (self == other)
8064 
 
8065 
class getBestDealsCount_result:
8066 
  """
8067 
  Attributes:
8068 
   - success
8069 
   - cex
8070 
  """
8071 
 
8072 
  thrift_spec = (
8073 
    (0, TType.I64, 'success', None, None, ), # 0
8074 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8075 
  )
8076 
 
8077 
  def __init__(self, success=None, cex=None,):
8078 
    self.success = success
8079 
    self.cex = cex
8080 
 
8081 
  def read(self, iprot):
8082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8084 
      return
8085 
    iprot.readStructBegin()
8086 
    while True:
8087 
      (fname, ftype, fid) = iprot.readFieldBegin()
8088 
      if ftype == TType.STOP:
8089 
        break
8090 
      if fid == 0:
8091 
        if ftype == TType.I64:
8092 
          self.success = iprot.readI64();
8093 
        else:
8094 
          iprot.skip(ftype)
8095 
      elif fid == 1:
8096 
        if ftype == TType.STRUCT:
8097 
          self.cex = CatalogServiceException()
8098 
          self.cex.read(iprot)
8099 
        else:
8100 
          iprot.skip(ftype)
8101 
      else:
8102 
        iprot.skip(ftype)
8103 
      iprot.readFieldEnd()
8104 
    iprot.readStructEnd()
8105 
 
8106 
  def write(self, oprot):
8107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8109 
      return
8110 
    oprot.writeStructBegin('getBestDealsCount_result')
8111 
    if self.success is not None:
8112 
      oprot.writeFieldBegin('success', TType.I64, 0)
8113 
      oprot.writeI64(self.success)
8114 
      oprot.writeFieldEnd()
8115 
    if self.cex is not None:
8116 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8117 
      self.cex.write(oprot)
8118 
      oprot.writeFieldEnd()
8119 
    oprot.writeFieldStop()
8120 
    oprot.writeStructEnd()
8121 
 
8122 
  def validate(self):
8123 
    return
8124 
 
8125 
 
8126 
  def __repr__(self):
8127 
    L = ['%s=%r' % (key, value)
8128 
      for key, value in self.__dict__.iteritems()]
8129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8130 
 
8131 
  def __eq__(self, other):
8132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8133 
 
8134 
  def __ne__(self, other):
8135 
    return not (self == other)
8136 
 
8137 
class getComingSoon_args:
8138 
 
8139 
  thrift_spec = (
8140 
  )
8141 
 
8142 
  def read(self, iprot):
8143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8145 
      return
8146 
    iprot.readStructBegin()
8147 
    while True:
8148 
      (fname, ftype, fid) = iprot.readFieldBegin()
8149 
      if ftype == TType.STOP:
8150 
        break
8151 
      else:
8152 
        iprot.skip(ftype)
8153 
      iprot.readFieldEnd()
8154 
    iprot.readStructEnd()
8155 
 
8156 
  def write(self, oprot):
8157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8159 
      return
8160 
    oprot.writeStructBegin('getComingSoon_args')
8161 
    oprot.writeFieldStop()
8162 
    oprot.writeStructEnd()
8163 
 
8164 
  def validate(self):
8165 
    return
8166 
 
8167 
 
8168 
  def __repr__(self):
8169 
    L = ['%s=%r' % (key, value)
8170 
      for key, value in self.__dict__.iteritems()]
8171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8172 
 
8173 
  def __eq__(self, other):
8174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8175 
 
8176 
  def __ne__(self, other):
8177 
    return not (self == other)
8178 
 
8179 
class getComingSoon_result:
8180 
  """
8181 
  Attributes:
8182 
   - success
8183 
   - isex
8184 
  """
8185 
 
8186 
  thrift_spec = (
8187 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8188 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8189 
  )
8190 
 
8191 
  def __init__(self, success=None, isex=None,):
8192 
    self.success = success
8193 
    self.isex = isex
8194 
 
8195 
  def read(self, iprot):
8196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8198 
      return
8199 
    iprot.readStructBegin()
8200 
    while True:
8201 
      (fname, ftype, fid) = iprot.readFieldBegin()
8202 
      if ftype == TType.STOP:
8203 
        break
8204 
      if fid == 0:
8205 
        if ftype == TType.LIST:
8206 
          self.success = []
8207 
          (_etype89, _size86) = iprot.readListBegin()
8208 
          for _i90 in xrange(_size86):
8209 
            _elem91 = Item()
8210 
            _elem91.read(iprot)
8211 
            self.success.append(_elem91)
8212 
          iprot.readListEnd()
8213 
        else:
8214 
          iprot.skip(ftype)
8215 
      elif fid == 1:
8216 
        if ftype == TType.STRUCT:
8217 
          self.isex = CatalogServiceException()
8218 
          self.isex.read(iprot)
8219 
        else:
8220 
          iprot.skip(ftype)
8221 
      else:
8222 
        iprot.skip(ftype)
8223 
      iprot.readFieldEnd()
8224 
    iprot.readStructEnd()
8225 
 
8226 
  def write(self, oprot):
8227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8229 
      return
8230 
    oprot.writeStructBegin('getComingSoon_result')
8231 
    if self.success is not None:
8232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8234 
      for iter92 in self.success:
8235 
        iter92.write(oprot)
8236 
      oprot.writeListEnd()
8237 
      oprot.writeFieldEnd()
8238 
    if self.isex is not None:
8239 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8240 
      self.isex.write(oprot)
8241 
      oprot.writeFieldEnd()
8242 
    oprot.writeFieldStop()
8243 
    oprot.writeStructEnd()
8244 
 
8245 
  def validate(self):
8246 
    return
8247 
 
8248 
 
8249 
  def __repr__(self):
8250 
    L = ['%s=%r' % (key, value)
8251 
      for key, value in self.__dict__.iteritems()]
8252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8253 
 
8254 
  def __eq__(self, other):
8255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8256 
 
8257 
  def __ne__(self, other):
8258 
    return not (self == other)
8259 
 
8260 
class getComingSoonCatalogIds_args:
8261 
  """
8262 
  Attributes:
8263 
   - beginIndex
8264 
   - totalItems
8265 
   - brand
8266 
   - category
8267 
  """
8268 
 
8269 
  thrift_spec = (
8270 
    None, # 0
8271 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8272 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8273 
    (3, TType.STRING, 'brand', None, None, ), # 3
8274 
    (4, TType.I64, 'category', None, None, ), # 4
8275 
  )
8276 
 
8277 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8278 
    self.beginIndex = beginIndex
8279 
    self.totalItems = totalItems
8280 
    self.brand = brand
8281 
    self.category = category
8282 
 
8283 
  def read(self, iprot):
8284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8286 
      return
8287 
    iprot.readStructBegin()
8288 
    while True:
8289 
      (fname, ftype, fid) = iprot.readFieldBegin()
8290 
      if ftype == TType.STOP:
8291 
        break
8292 
      if fid == 1:
8293 
        if ftype == TType.I64:
8294 
          self.beginIndex = iprot.readI64();
8295 
        else:
8296 
          iprot.skip(ftype)
8297 
      elif fid == 2:
8298 
        if ftype == TType.I64:
8299 
          self.totalItems = iprot.readI64();
8300 
        else:
8301 
          iprot.skip(ftype)
8302 
      elif fid == 3:
8303 
        if ftype == TType.STRING:
8304 
          self.brand = iprot.readString();
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      elif fid == 4:
8308 
        if ftype == TType.I64:
8309 
          self.category = iprot.readI64();
8310 
        else:
8311 
          iprot.skip(ftype)
8312 
      else:
8313 
        iprot.skip(ftype)
8314 
      iprot.readFieldEnd()
8315 
    iprot.readStructEnd()
8316 
 
8317 
  def write(self, oprot):
8318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8320 
      return
8321 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8322 
    if self.beginIndex is not None:
8323 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8324 
      oprot.writeI64(self.beginIndex)
8325 
      oprot.writeFieldEnd()
8326 
    if self.totalItems is not None:
8327 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8328 
      oprot.writeI64(self.totalItems)
8329 
      oprot.writeFieldEnd()
8330 
    if self.brand is not None:
8331 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8332 
      oprot.writeString(self.brand)
8333 
      oprot.writeFieldEnd()
8334 
    if self.category is not None:
8335 
      oprot.writeFieldBegin('category', TType.I64, 4)
8336 
      oprot.writeI64(self.category)
8337 
      oprot.writeFieldEnd()
8338 
    oprot.writeFieldStop()
8339 
    oprot.writeStructEnd()
8340 
 
8341 
  def validate(self):
8342 
    return
8343 
 
8344 
 
8345 
  def __repr__(self):
8346 
    L = ['%s=%r' % (key, value)
8347 
      for key, value in self.__dict__.iteritems()]
8348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8349 
 
8350 
  def __eq__(self, other):
8351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8352 
 
8353 
  def __ne__(self, other):
8354 
    return not (self == other)
8355 
 
8356 
class getComingSoonCatalogIds_result:
8357 
  """
8358 
  Attributes:
8359 
   - success
8360 
   - cex
8361 
  """
8362 
 
8363 
  thrift_spec = (
8364 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8365 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8366 
  )
8367 
 
8368 
  def __init__(self, success=None, cex=None,):
8369 
    self.success = success
8370 
    self.cex = cex
8371 
 
8372 
  def read(self, iprot):
8373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8375 
      return
8376 
    iprot.readStructBegin()
8377 
    while True:
8378 
      (fname, ftype, fid) = iprot.readFieldBegin()
8379 
      if ftype == TType.STOP:
8380 
        break
8381 
      if fid == 0:
8382 
        if ftype == TType.LIST:
8383 
          self.success = []
8384 
          (_etype96, _size93) = iprot.readListBegin()
8385 
          for _i97 in xrange(_size93):
8386 
            _elem98 = iprot.readI64();
8387 
            self.success.append(_elem98)
8388 
          iprot.readListEnd()
8389 
        else:
8390 
          iprot.skip(ftype)
8391 
      elif fid == 1:
8392 
        if ftype == TType.STRUCT:
8393 
          self.cex = CatalogServiceException()
8394 
          self.cex.read(iprot)
8395 
        else:
8396 
          iprot.skip(ftype)
8397 
      else:
8398 
        iprot.skip(ftype)
8399 
      iprot.readFieldEnd()
8400 
    iprot.readStructEnd()
8401 
 
8402 
  def write(self, oprot):
8403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8405 
      return
8406 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8407 
    if self.success is not None:
8408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8409 
      oprot.writeListBegin(TType.I64, len(self.success))
8410 
      for iter99 in self.success:
8411 
        oprot.writeI64(iter99)
8412 
      oprot.writeListEnd()
8413 
      oprot.writeFieldEnd()
8414 
    if self.cex is not None:
8415 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8416 
      self.cex.write(oprot)
8417 
      oprot.writeFieldEnd()
8418 
    oprot.writeFieldStop()
8419 
    oprot.writeStructEnd()
8420 
 
8421 
  def validate(self):
8422 
    return
8423 
 
8424 
 
8425 
  def __repr__(self):
8426 
    L = ['%s=%r' % (key, value)
8427 
      for key, value in self.__dict__.iteritems()]
8428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8429 
 
8430 
  def __eq__(self, other):
8431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8432 
 
8433 
  def __ne__(self, other):
8434 
    return not (self == other)
8435 
 
8436 
class getComingSoonCount_args:
8437 
 
8438 
  thrift_spec = (
8439 
  )
8440 
 
8441 
  def read(self, iprot):
8442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8444 
      return
8445 
    iprot.readStructBegin()
8446 
    while True:
8447 
      (fname, ftype, fid) = iprot.readFieldBegin()
8448 
      if ftype == TType.STOP:
8449 
        break
8450 
      else:
8451 
        iprot.skip(ftype)
8452 
      iprot.readFieldEnd()
8453 
    iprot.readStructEnd()
8454 
 
8455 
  def write(self, oprot):
8456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8458 
      return
8459 
    oprot.writeStructBegin('getComingSoonCount_args')
8460 
    oprot.writeFieldStop()
8461 
    oprot.writeStructEnd()
8462 
 
8463 
  def validate(self):
8464 
    return
8465 
 
8466 
 
8467 
  def __repr__(self):
8468 
    L = ['%s=%r' % (key, value)
8469 
      for key, value in self.__dict__.iteritems()]
8470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8471 
 
8472 
  def __eq__(self, other):
8473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8474 
 
8475 
  def __ne__(self, other):
8476 
    return not (self == other)
8477 
 
8478 
class getComingSoonCount_result:
8479 
  """
8480 
  Attributes:
8481 
   - success
8482 
   - cex
8483 
  """
8484 
 
8485 
  thrift_spec = (
8486 
    (0, TType.I64, 'success', None, None, ), # 0
8487 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8488 
  )
8489 
 
8490 
  def __init__(self, success=None, cex=None,):
8491 
    self.success = success
8492 
    self.cex = cex
8493 
 
8494 
  def read(self, iprot):
8495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8497 
      return
8498 
    iprot.readStructBegin()
8499 
    while True:
8500 
      (fname, ftype, fid) = iprot.readFieldBegin()
8501 
      if ftype == TType.STOP:
8502 
        break
8503 
      if fid == 0:
8504 
        if ftype == TType.I64:
8505 
          self.success = iprot.readI64();
8506 
        else:
8507 
          iprot.skip(ftype)
8508 
      elif fid == 1:
8509 
        if ftype == TType.STRUCT:
8510 
          self.cex = CatalogServiceException()
8511 
          self.cex.read(iprot)
8512 
        else:
8513 
          iprot.skip(ftype)
8514 
      else:
8515 
        iprot.skip(ftype)
8516 
      iprot.readFieldEnd()
8517 
    iprot.readStructEnd()
8518 
 
8519 
  def write(self, oprot):
8520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8522 
      return
8523 
    oprot.writeStructBegin('getComingSoonCount_result')
8524 
    if self.success is not None:
8525 
      oprot.writeFieldBegin('success', TType.I64, 0)
8526 
      oprot.writeI64(self.success)
8527 
      oprot.writeFieldEnd()
8528 
    if self.cex is not None:
8529 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8530 
      self.cex.write(oprot)
8531 
      oprot.writeFieldEnd()
8532 
    oprot.writeFieldStop()
8533 
    oprot.writeStructEnd()
8534 
 
8535 
  def validate(self):
8536 
    return
8537 
 
8538 
 
8539 
  def __repr__(self):
8540 
    L = ['%s=%r' % (key, value)
8541 
      for key, value in self.__dict__.iteritems()]
8542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8543 
 
8544 
  def __eq__(self, other):
8545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8546 
 
8547 
  def __ne__(self, other):
8548 
    return not (self == other)
8549 
 
8550 
class getLatestArrivals_args:
8551 
 
8552 
  thrift_spec = (
8553 
  )
8554 
 
8555 
  def read(self, iprot):
8556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8558 
      return
8559 
    iprot.readStructBegin()
8560 
    while True:
8561 
      (fname, ftype, fid) = iprot.readFieldBegin()
8562 
      if ftype == TType.STOP:
8563 
        break
8564 
      else:
8565 
        iprot.skip(ftype)
8566 
      iprot.readFieldEnd()
8567 
    iprot.readStructEnd()
8568 
 
8569 
  def write(self, oprot):
8570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8572 
      return
8573 
    oprot.writeStructBegin('getLatestArrivals_args')
8574 
    oprot.writeFieldStop()
8575 
    oprot.writeStructEnd()
8576 
 
8577 
  def validate(self):
8578 
    return
8579 
 
8580 
 
8581 
  def __repr__(self):
8582 
    L = ['%s=%r' % (key, value)
8583 
      for key, value in self.__dict__.iteritems()]
8584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8585 
 
8586 
  def __eq__(self, other):
8587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8588 
 
8589 
  def __ne__(self, other):
8590 
    return not (self == other)
8591 
 
8592 
class getLatestArrivals_result:
8593 
  """
8594 
  Attributes:
8595 
   - success
8596 
   - isex
8597 
  """
8598 
 
8599 
  thrift_spec = (
8600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8601 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8602 
  )
8603 
 
8604 
  def __init__(self, success=None, isex=None,):
8605 
    self.success = success
8606 
    self.isex = isex
8607 
 
8608 
  def read(self, iprot):
8609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8611 
      return
8612 
    iprot.readStructBegin()
8613 
    while True:
8614 
      (fname, ftype, fid) = iprot.readFieldBegin()
8615 
      if ftype == TType.STOP:
8616 
        break
8617 
      if fid == 0:
8618 
        if ftype == TType.LIST:
8619 
          self.success = []
8620 
          (_etype103, _size100) = iprot.readListBegin()
8621 
          for _i104 in xrange(_size100):
8622 
            _elem105 = Item()
8623 
            _elem105.read(iprot)
8624 
            self.success.append(_elem105)
8625 
          iprot.readListEnd()
8626 
        else:
8627 
          iprot.skip(ftype)
8628 
      elif fid == 1:
8629 
        if ftype == TType.STRUCT:
8630 
          self.isex = CatalogServiceException()
8631 
          self.isex.read(iprot)
8632 
        else:
8633 
          iprot.skip(ftype)
8634 
      else:
8635 
        iprot.skip(ftype)
8636 
      iprot.readFieldEnd()
8637 
    iprot.readStructEnd()
8638 
 
8639 
  def write(self, oprot):
8640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8642 
      return
8643 
    oprot.writeStructBegin('getLatestArrivals_result')
8644 
    if self.success is not None:
8645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8646 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8647 
      for iter106 in self.success:
8648 
        iter106.write(oprot)
8649 
      oprot.writeListEnd()
8650 
      oprot.writeFieldEnd()
8651 
    if self.isex is not None:
8652 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8653 
      self.isex.write(oprot)
8654 
      oprot.writeFieldEnd()
8655 
    oprot.writeFieldStop()
8656 
    oprot.writeStructEnd()
8657 
 
8658 
  def validate(self):
8659 
    return
8660 
 
8661 
 
8662 
  def __repr__(self):
8663 
    L = ['%s=%r' % (key, value)
8664 
      for key, value in self.__dict__.iteritems()]
8665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8666 
 
8667 
  def __eq__(self, other):
8668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8669 
 
8670 
  def __ne__(self, other):
8671 
    return not (self == other)
8672 
 
8673 
class getLatestArrivalsCatalogIds_args:
8674 
  """
8675 
  Attributes:
8676 
   - beginIndex
8677 
   - totalItems
8678 
   - brand
8679 
   - categories
8680 
  """
8681 
 
8682 
  thrift_spec = (
8683 
    None, # 0
8684 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8685 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8686 
    (3, TType.STRING, 'brand', None, None, ), # 3
8687 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8688 
  )
8689 
 
8690 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8691 
    self.beginIndex = beginIndex
8692 
    self.totalItems = totalItems
8693 
    self.brand = brand
8694 
    self.categories = categories
8695 
 
8696 
  def read(self, iprot):
8697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8699 
      return
8700 
    iprot.readStructBegin()
8701 
    while True:
8702 
      (fname, ftype, fid) = iprot.readFieldBegin()
8703 
      if ftype == TType.STOP:
8704 
        break
8705 
      if fid == 1:
8706 
        if ftype == TType.I64:
8707 
          self.beginIndex = iprot.readI64();
8708 
        else:
8709 
          iprot.skip(ftype)
8710 
      elif fid == 2:
8711 
        if ftype == TType.I64:
8712 
          self.totalItems = iprot.readI64();
8713 
        else:
8714 
          iprot.skip(ftype)
8715 
      elif fid == 3:
8716 
        if ftype == TType.STRING:
8717 
          self.brand = iprot.readString();
8718 
        else:
8719 
          iprot.skip(ftype)
8720 
      elif fid == 4:
8721 
        if ftype == TType.LIST:
8722 
          self.categories = []
8723 
          (_etype110, _size107) = iprot.readListBegin()
8724 
          for _i111 in xrange(_size107):
8725 
            _elem112 = iprot.readI64();
8726 
            self.categories.append(_elem112)
8727 
          iprot.readListEnd()
8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      else:
8731 
        iprot.skip(ftype)
8732 
      iprot.readFieldEnd()
8733 
    iprot.readStructEnd()
8734 
 
8735 
  def write(self, oprot):
8736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8738 
      return
8739 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8740 
    if self.beginIndex is not None:
8741 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8742 
      oprot.writeI64(self.beginIndex)
8743 
      oprot.writeFieldEnd()
8744 
    if self.totalItems is not None:
8745 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8746 
      oprot.writeI64(self.totalItems)
8747 
      oprot.writeFieldEnd()
8748 
    if self.brand is not None:
8749 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8750 
      oprot.writeString(self.brand)
8751 
      oprot.writeFieldEnd()
8752 
    if self.categories is not None:
8753 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8754 
      oprot.writeListBegin(TType.I64, len(self.categories))
8755 
      for iter113 in self.categories:
8756 
        oprot.writeI64(iter113)
8757 
      oprot.writeListEnd()
8758 
      oprot.writeFieldEnd()
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
8762 
  def validate(self):
8763 
    return
8764 
 
8765 
 
8766 
  def __repr__(self):
8767 
    L = ['%s=%r' % (key, value)
8768 
      for key, value in self.__dict__.iteritems()]
8769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8770 
 
8771 
  def __eq__(self, other):
8772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8773 
 
8774 
  def __ne__(self, other):
8775 
    return not (self == other)
8776 
 
8777 
class getLatestArrivalsCatalogIds_result:
8778 
  """
8779 
  Attributes:
8780 
   - success
8781 
   - cex
8782 
  """
8783 
 
8784 
  thrift_spec = (
8785 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8786 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8787 
  )
8788 
 
8789 
  def __init__(self, success=None, cex=None,):
8790 
    self.success = success
8791 
    self.cex = cex
8792 
 
8793 
  def read(self, iprot):
8794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8796 
      return
8797 
    iprot.readStructBegin()
8798 
    while True:
8799 
      (fname, ftype, fid) = iprot.readFieldBegin()
8800 
      if ftype == TType.STOP:
8801 
        break
8802 
      if fid == 0:
8803 
        if ftype == TType.LIST:
8804 
          self.success = []
8805 
          (_etype117, _size114) = iprot.readListBegin()
8806 
          for _i118 in xrange(_size114):
8807 
            _elem119 = iprot.readI64();
8808 
            self.success.append(_elem119)
8809 
          iprot.readListEnd()
8810 
        else:
8811 
          iprot.skip(ftype)
8812 
      elif fid == 1:
8813 
        if ftype == TType.STRUCT:
8814 
          self.cex = CatalogServiceException()
8815 
          self.cex.read(iprot)
8816 
        else:
8817 
          iprot.skip(ftype)
8818 
      else:
8819 
        iprot.skip(ftype)
8820 
      iprot.readFieldEnd()
8821 
    iprot.readStructEnd()
8822 
 
8823 
  def write(self, oprot):
8824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8826 
      return
8827 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8828 
    if self.success is not None:
8829 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8830 
      oprot.writeListBegin(TType.I64, len(self.success))
8831 
      for iter120 in self.success:
8832 
        oprot.writeI64(iter120)
8833 
      oprot.writeListEnd()
8834 
      oprot.writeFieldEnd()
8835 
    if self.cex is not None:
8836 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8837 
      self.cex.write(oprot)
8838 
      oprot.writeFieldEnd()
8839 
    oprot.writeFieldStop()
8840 
    oprot.writeStructEnd()
8841 
 
8842 
  def validate(self):
8843 
    return
8844 
 
8845 
 
8846 
  def __repr__(self):
8847 
    L = ['%s=%r' % (key, value)
8848 
      for key, value in self.__dict__.iteritems()]
8849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8850 
 
8851 
  def __eq__(self, other):
8852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8853 
 
8854 
  def __ne__(self, other):
8855 
    return not (self == other)
8856 
 
8857 
class getLatestArrivalsCount_args:
8858 
 
8859 
  thrift_spec = (
8860 
  )
8861 
 
8862 
  def read(self, iprot):
8863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8865 
      return
8866 
    iprot.readStructBegin()
8867 
    while True:
8868 
      (fname, ftype, fid) = iprot.readFieldBegin()
8869 
      if ftype == TType.STOP:
8870 
        break
8871 
      else:
8872 
        iprot.skip(ftype)
8873 
      iprot.readFieldEnd()
8874 
    iprot.readStructEnd()
8875 
 
8876 
  def write(self, oprot):
8877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8879 
      return
8880 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8881 
    oprot.writeFieldStop()
8882 
    oprot.writeStructEnd()
8883 
 
8884 
  def validate(self):
8885 
    return
8886 
 
8887 
 
8888 
  def __repr__(self):
8889 
    L = ['%s=%r' % (key, value)
8890 
      for key, value in self.__dict__.iteritems()]
8891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8892 
 
8893 
  def __eq__(self, other):
8894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8895 
 
8896 
  def __ne__(self, other):
8897 
    return not (self == other)
8898 
 
8899 
class getLatestArrivalsCount_result:
8900 
  """
8901 
  Attributes:
8902 
   - success
8903 
   - cex
8904 
  """
8905 
 
8906 
  thrift_spec = (
8907 
    (0, TType.I64, 'success', None, None, ), # 0
8908 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8909 
  )
8910 
 
8911 
  def __init__(self, success=None, cex=None,):
8912 
    self.success = success
8913 
    self.cex = cex
8914 
 
8915 
  def read(self, iprot):
8916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8918 
      return
8919 
    iprot.readStructBegin()
8920 
    while True:
8921 
      (fname, ftype, fid) = iprot.readFieldBegin()
8922 
      if ftype == TType.STOP:
8923 
        break
8924 
      if fid == 0:
8925 
        if ftype == TType.I64:
8926 
          self.success = iprot.readI64();
8927 
        else:
8928 
          iprot.skip(ftype)
8929 
      elif fid == 1:
8930 
        if ftype == TType.STRUCT:
8931 
          self.cex = CatalogServiceException()
8932 
          self.cex.read(iprot)
8933 
        else:
8934 
          iprot.skip(ftype)
8935 
      else:
8936 
        iprot.skip(ftype)
8937 
      iprot.readFieldEnd()
8938 
    iprot.readStructEnd()
8939 
 
8940 
  def write(self, oprot):
8941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8943 
      return
8944 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8945 
    if self.success is not None:
8946 
      oprot.writeFieldBegin('success', TType.I64, 0)
8947 
      oprot.writeI64(self.success)
8948 
      oprot.writeFieldEnd()
8949 
    if self.cex is not None:
8950 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8951 
      self.cex.write(oprot)
8952 
      oprot.writeFieldEnd()
8953 
    oprot.writeFieldStop()
8954 
    oprot.writeStructEnd()
8955 
 
8956 
  def validate(self):
8957 
    return
8958 
 
8959 
 
8960 
  def __repr__(self):
8961 
    L = ['%s=%r' % (key, value)
8962 
      for key, value in self.__dict__.iteritems()]
8963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8964 
 
8965 
  def __eq__(self, other):
8966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8967 
 
8968 
  def __ne__(self, other):
8969 
    return not (self == other)
8970 
 
8971 
class generateNewEntityID_args:
8972 
 
8973 
  thrift_spec = (
8974 
  )
8975 
 
8976 
  def read(self, iprot):
8977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8979 
      return
8980 
    iprot.readStructBegin()
8981 
    while True:
8982 
      (fname, ftype, fid) = iprot.readFieldBegin()
8983 
      if ftype == TType.STOP:
8984 
        break
8985 
      else:
8986 
        iprot.skip(ftype)
8987 
      iprot.readFieldEnd()
8988 
    iprot.readStructEnd()
8989 
 
8990 
  def write(self, oprot):
8991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8993 
      return
8994 
    oprot.writeStructBegin('generateNewEntityID_args')
8995 
    oprot.writeFieldStop()
8996 
    oprot.writeStructEnd()
8997 
 
8998 
  def validate(self):
8999 
    return
9000 
 
9001 
 
9002 
  def __repr__(self):
9003 
    L = ['%s=%r' % (key, value)
9004 
      for key, value in self.__dict__.iteritems()]
9005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9006 
 
9007 
  def __eq__(self, other):
9008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9009 
 
9010 
  def __ne__(self, other):
9011 
    return not (self == other)
9012 
 
9013 
class generateNewEntityID_result:
9014 
  """
9015 
  Attributes:
9016 
   - success
9017 
  """
9018 
 
9019 
  thrift_spec = (
9020 
    (0, TType.I64, 'success', None, None, ), # 0
9021 
  )
9022 
 
9023 
  def __init__(self, success=None,):
9024 
    self.success = success
9025 
 
9026 
  def read(self, iprot):
9027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9029 
      return
9030 
    iprot.readStructBegin()
9031 
    while True:
9032 
      (fname, ftype, fid) = iprot.readFieldBegin()
9033 
      if ftype == TType.STOP:
9034 
        break
9035 
      if fid == 0:
9036 
        if ftype == TType.I64:
9037 
          self.success = iprot.readI64();
9038 
        else:
9039 
          iprot.skip(ftype)
9040 
      else:
9041 
        iprot.skip(ftype)
9042 
      iprot.readFieldEnd()
9043 
    iprot.readStructEnd()
9044 
 
9045 
  def write(self, oprot):
9046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9048 
      return
9049 
    oprot.writeStructBegin('generateNewEntityID_result')
9050 
    if self.success is not None:
9051 
      oprot.writeFieldBegin('success', TType.I64, 0)
9052 
      oprot.writeI64(self.success)
9053 
      oprot.writeFieldEnd()
9054 
    oprot.writeFieldStop()
9055 
    oprot.writeStructEnd()
9056 
 
9057 
  def validate(self):
9058 
    return
9059 
 
9060 
 
9061 
  def __repr__(self):
9062 
    L = ['%s=%r' % (key, value)
9063 
      for key, value in self.__dict__.iteritems()]
9064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9065 
 
9066 
  def __eq__(self, other):
9067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9068 
 
9069 
  def __ne__(self, other):
9070 
    return not (self == other)
9071 
 
9072 
class addCategory_args:
9073 
  """
9074 
  Attributes:
9075 
   - category
9076 
  """
9077 
 
9078 
  thrift_spec = (
9079 
    None, # 0
9080 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9081 
  )
9082 
 
9083 
  def __init__(self, category=None,):
9084 
    self.category = category
9085 
 
9086 
  def read(self, iprot):
9087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9089 
      return
9090 
    iprot.readStructBegin()
9091 
    while True:
9092 
      (fname, ftype, fid) = iprot.readFieldBegin()
9093 
      if ftype == TType.STOP:
9094 
        break
9095 
      if fid == 1:
9096 
        if ftype == TType.STRUCT:
9097 
          self.category = Category()
9098 
          self.category.read(iprot)
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      else:
9102 
        iprot.skip(ftype)
9103 
      iprot.readFieldEnd()
9104 
    iprot.readStructEnd()
9105 
 
9106 
  def write(self, oprot):
9107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9109 
      return
9110 
    oprot.writeStructBegin('addCategory_args')
9111 
    if self.category is not None:
9112 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9113 
      self.category.write(oprot)
9114 
      oprot.writeFieldEnd()
9115 
    oprot.writeFieldStop()
9116 
    oprot.writeStructEnd()
9117 
 
9118 
  def validate(self):
9119 
    return
9120 
 
9121 
 
9122 
  def __repr__(self):
9123 
    L = ['%s=%r' % (key, value)
9124 
      for key, value in self.__dict__.iteritems()]
9125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9126 
 
9127 
  def __eq__(self, other):
9128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9129 
 
9130 
  def __ne__(self, other):
9131 
    return not (self == other)
9132 
 
9133 
class addCategory_result:
9134 
  """
9135 
  Attributes:
9136 
   - success
9137 
  """
9138 
 
9139 
  thrift_spec = (
9140 
    (0, TType.BOOL, 'success', None, None, ), # 0
9141 
  )
9142 
 
9143 
  def __init__(self, success=None,):
9144 
    self.success = success
9145 
 
9146 
  def read(self, iprot):
9147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9149 
      return
9150 
    iprot.readStructBegin()
9151 
    while True:
9152 
      (fname, ftype, fid) = iprot.readFieldBegin()
9153 
      if ftype == TType.STOP:
9154 
        break
9155 
      if fid == 0:
9156 
        if ftype == TType.BOOL:
9157 
          self.success = iprot.readBool();
9158 
        else:
9159 
          iprot.skip(ftype)
9160 
      else:
9161 
        iprot.skip(ftype)
9162 
      iprot.readFieldEnd()
9163 
    iprot.readStructEnd()
9164 
 
9165 
  def write(self, oprot):
9166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9168 
      return
9169 
    oprot.writeStructBegin('addCategory_result')
9170 
    if self.success is not None:
9171 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9172 
      oprot.writeBool(self.success)
9173 
      oprot.writeFieldEnd()
9174 
    oprot.writeFieldStop()
9175 
    oprot.writeStructEnd()
9176 
 
9177 
  def validate(self):
9178 
    return
9179 
 
9180 
 
9181 
  def __repr__(self):
9182 
    L = ['%s=%r' % (key, value)
9183 
      for key, value in self.__dict__.iteritems()]
9184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9185 
 
9186 
  def __eq__(self, other):
9187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9188 
 
9189 
  def __ne__(self, other):
9190 
    return not (self == other)
9191 
 
9192 
class getCategory_args:
9193 
  """
9194 
  Attributes:
9195 
   - id
9196 
  """
9197 
 
9198 
  thrift_spec = (
9199 
    None, # 0
9200 
    (1, TType.I64, 'id', None, None, ), # 1
9201 
  )
9202 
 
9203 
  def __init__(self, id=None,):
9204 
    self.id = id
9205 
 
9206 
  def read(self, iprot):
9207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9209 
      return
9210 
    iprot.readStructBegin()
9211 
    while True:
9212 
      (fname, ftype, fid) = iprot.readFieldBegin()
9213 
      if ftype == TType.STOP:
9214 
        break
9215 
      if fid == 1:
9216 
        if ftype == TType.I64:
9217 
          self.id = iprot.readI64();
9218 
        else:
9219 
          iprot.skip(ftype)
9220 
      else:
9221 
        iprot.skip(ftype)
9222 
      iprot.readFieldEnd()
9223 
    iprot.readStructEnd()
9224 
 
9225 
  def write(self, oprot):
9226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9228 
      return
9229 
    oprot.writeStructBegin('getCategory_args')
9230 
    if self.id is not None:
9231 
      oprot.writeFieldBegin('id', TType.I64, 1)
9232 
      oprot.writeI64(self.id)
9233 
      oprot.writeFieldEnd()
9234 
    oprot.writeFieldStop()
9235 
    oprot.writeStructEnd()
9236 
 
9237 
  def validate(self):
9238 
    return
9239 
 
9240 
 
9241 
  def __repr__(self):
9242 
    L = ['%s=%r' % (key, value)
9243 
      for key, value in self.__dict__.iteritems()]
9244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9245 
 
9246 
  def __eq__(self, other):
9247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9248 
 
9249 
  def __ne__(self, other):
9250 
    return not (self == other)
9251 
 
9252 
class getCategory_result:
9253 
  """
9254 
  Attributes:
9255 
   - success
9256 
  """
9257 
 
9258 
  thrift_spec = (
9259 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9260 
  )
9261 
 
9262 
  def __init__(self, success=None,):
9263 
    self.success = success
9264 
 
9265 
  def read(self, iprot):
9266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9268 
      return
9269 
    iprot.readStructBegin()
9270 
    while True:
9271 
      (fname, ftype, fid) = iprot.readFieldBegin()
9272 
      if ftype == TType.STOP:
9273 
        break
9274 
      if fid == 0:
9275 
        if ftype == TType.STRUCT:
9276 
          self.success = Category()
9277 
          self.success.read(iprot)
9278 
        else:
9279 
          iprot.skip(ftype)
9280 
      else:
9281 
        iprot.skip(ftype)
9282 
      iprot.readFieldEnd()
9283 
    iprot.readStructEnd()
9284 
 
9285 
  def write(self, oprot):
9286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9288 
      return
9289 
    oprot.writeStructBegin('getCategory_result')
9290 
    if self.success is not None:
9291 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9292 
      self.success.write(oprot)
9293 
      oprot.writeFieldEnd()
9294 
    oprot.writeFieldStop()
9295 
    oprot.writeStructEnd()
9296 
 
9297 
  def validate(self):
9298 
    return
9299 
 
9300 
 
9301 
  def __repr__(self):
9302 
    L = ['%s=%r' % (key, value)
9303 
      for key, value in self.__dict__.iteritems()]
9304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9305 
 
9306 
  def __eq__(self, other):
9307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9308 
 
9309 
  def __ne__(self, other):
9310 
    return not (self == other)
9311 
 
9312 
class getAllCategories_args:
9313 
 
9314 
  thrift_spec = (
9315 
  )
9316 
 
9317 
  def read(self, iprot):
9318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9320 
      return
9321 
    iprot.readStructBegin()
9322 
    while True:
9323 
      (fname, ftype, fid) = iprot.readFieldBegin()
9324 
      if ftype == TType.STOP:
9325 
        break
9326 
      else:
9327 
        iprot.skip(ftype)
9328 
      iprot.readFieldEnd()
9329 
    iprot.readStructEnd()
9330 
 
9331 
  def write(self, oprot):
9332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9334 
      return
9335 
    oprot.writeStructBegin('getAllCategories_args')
9336 
    oprot.writeFieldStop()
9337 
    oprot.writeStructEnd()
9338 
 
9339 
  def validate(self):
9340 
    return
9341 
 
9342 
 
9343 
  def __repr__(self):
9344 
    L = ['%s=%r' % (key, value)
9345 
      for key, value in self.__dict__.iteritems()]
9346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9347 
 
9348 
  def __eq__(self, other):
9349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9350 
 
9351 
  def __ne__(self, other):
9352 
    return not (self == other)
9353 
 
9354 
class getAllCategories_result:
9355 
  """
9356 
  Attributes:
9357 
   - success
9358 
  """
9359 
 
9360 
  thrift_spec = (
9361 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9362 
  )
9363 
 
9364 
  def __init__(self, success=None,):
9365 
    self.success = success
9366 
 
9367 
  def read(self, iprot):
9368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9370 
      return
9371 
    iprot.readStructBegin()
9372 
    while True:
9373 
      (fname, ftype, fid) = iprot.readFieldBegin()
9374 
      if ftype == TType.STOP:
9375 
        break
9376 
      if fid == 0:
9377 
        if ftype == TType.LIST:
9378 
          self.success = []
9379 
          (_etype124, _size121) = iprot.readListBegin()
9380 
          for _i125 in xrange(_size121):
9381 
            _elem126 = Category()
9382 
            _elem126.read(iprot)
9383 
            self.success.append(_elem126)
9384 
          iprot.readListEnd()
9385 
        else:
9386 
          iprot.skip(ftype)
9387 
      else:
9388 
        iprot.skip(ftype)
9389 
      iprot.readFieldEnd()
9390 
    iprot.readStructEnd()
9391 
 
9392 
  def write(self, oprot):
9393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9395 
      return
9396 
    oprot.writeStructBegin('getAllCategories_result')
9397 
    if self.success is not None:
9398 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9399 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9400 
      for iter127 in self.success:
9401 
        iter127.write(oprot)
9402 
      oprot.writeListEnd()
9403 
      oprot.writeFieldEnd()
9404 
    oprot.writeFieldStop()
9405 
    oprot.writeStructEnd()
9406 
 
9407 
  def validate(self):
9408 
    return
9409 
 
9410 
 
9411 
  def __repr__(self):
9412 
    L = ['%s=%r' % (key, value)
9413 
      for key, value in self.__dict__.iteritems()]
9414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9415 
 
9416 
  def __eq__(self, other):
9417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9418 
 
9419 
  def __ne__(self, other):
9420 
    return not (self == other)
9421 
 
9422 
class getAllSimilarItems_args:
9423 
  """
9424 
  Attributes:
9425 
   - itemId
9426 
  """
9427 
 
9428 
  thrift_spec = (
9429 
    None, # 0
9430 
    (1, TType.I64, 'itemId', None, None, ), # 1
9431 
  )
9432 
 
9433 
  def __init__(self, itemId=None,):
9434 
    self.itemId = itemId
9435 
 
9436 
  def read(self, iprot):
9437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9439 
      return
9440 
    iprot.readStructBegin()
9441 
    while True:
9442 
      (fname, ftype, fid) = iprot.readFieldBegin()
9443 
      if ftype == TType.STOP:
9444 
        break
9445 
      if fid == 1:
9446 
        if ftype == TType.I64:
9447 
          self.itemId = iprot.readI64();
9448 
        else:
9449 
          iprot.skip(ftype)
9450 
      else:
9451 
        iprot.skip(ftype)
9452 
      iprot.readFieldEnd()
9453 
    iprot.readStructEnd()
9454 
 
9455 
  def write(self, oprot):
9456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9458 
      return
9459 
    oprot.writeStructBegin('getAllSimilarItems_args')
9460 
    if self.itemId is not None:
9461 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9462 
      oprot.writeI64(self.itemId)
9463 
      oprot.writeFieldEnd()
9464 
    oprot.writeFieldStop()
9465 
    oprot.writeStructEnd()
9466 
 
9467 
  def validate(self):
9468 
    return
9469 
 
9470 
 
9471 
  def __repr__(self):
9472 
    L = ['%s=%r' % (key, value)
9473 
      for key, value in self.__dict__.iteritems()]
9474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9475 
 
9476 
  def __eq__(self, other):
9477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9478 
 
9479 
  def __ne__(self, other):
9480 
    return not (self == other)
9481 
 
9482 
class getAllSimilarItems_result:
9483 
  """
9484 
  Attributes:
9485 
   - success
9486 
  """
9487 
 
9488 
  thrift_spec = (
9489 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9490 
  )
9491 
 
9492 
  def __init__(self, success=None,):
9493 
    self.success = success
9494 
 
9495 
  def read(self, iprot):
9496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9498 
      return
9499 
    iprot.readStructBegin()
9500 
    while True:
9501 
      (fname, ftype, fid) = iprot.readFieldBegin()
9502 
      if ftype == TType.STOP:
9503 
        break
9504 
      if fid == 0:
9505 
        if ftype == TType.LIST:
9506 
          self.success = []
9507 
          (_etype131, _size128) = iprot.readListBegin()
9508 
          for _i132 in xrange(_size128):
9509 
            _elem133 = Item()
9510 
            _elem133.read(iprot)
9511 
            self.success.append(_elem133)
9512 
          iprot.readListEnd()
9513 
        else:
9514 
          iprot.skip(ftype)
9515 
      else:
9516 
        iprot.skip(ftype)
9517 
      iprot.readFieldEnd()
9518 
    iprot.readStructEnd()
9519 
 
9520 
  def write(self, oprot):
9521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9523 
      return
9524 
    oprot.writeStructBegin('getAllSimilarItems_result')
9525 
    if self.success is not None:
9526 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9527 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9528 
      for iter134 in self.success:
9529 
        iter134.write(oprot)
9530 
      oprot.writeListEnd()
9531 
      oprot.writeFieldEnd()
9532 
    oprot.writeFieldStop()
9533 
    oprot.writeStructEnd()
9534 
 
9535 
  def validate(self):
9536 
    return
9537 
 
9538 
 
9539 
  def __repr__(self):
9540 
    L = ['%s=%r' % (key, value)
9541 
      for key, value in self.__dict__.iteritems()]
9542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9543 
 
9544 
  def __eq__(self, other):
9545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9546 
 
9547 
  def __ne__(self, other):
9548 
    return not (self == other)
9549 
 
9550 
class addSimilarItem_args:
9551 
  """
9552 
  Attributes:
9553 
   - itemId
9554 
   - catalogItemId
9555 
  """
9556 
 
9557 
  thrift_spec = (
9558 
    None, # 0
9559 
    (1, TType.I64, 'itemId', None, None, ), # 1
9560 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9561 
  )
9562 
 
9563 
  def __init__(self, itemId=None, catalogItemId=None,):
9564 
    self.itemId = itemId
9565 
    self.catalogItemId = catalogItemId
9566 
 
9567 
  def read(self, iprot):
9568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9570 
      return
9571 
    iprot.readStructBegin()
9572 
    while True:
9573 
      (fname, ftype, fid) = iprot.readFieldBegin()
9574 
      if ftype == TType.STOP:
9575 
        break
9576 
      if fid == 1:
9577 
        if ftype == TType.I64:
9578 
          self.itemId = iprot.readI64();
9579 
        else:
9580 
          iprot.skip(ftype)
9581 
      elif fid == 2:
9582 
        if ftype == TType.I64:
9583 
          self.catalogItemId = iprot.readI64();
9584 
        else:
9585 
          iprot.skip(ftype)
9586 
      else:
9587 
        iprot.skip(ftype)
9588 
      iprot.readFieldEnd()
9589 
    iprot.readStructEnd()
9590 
 
9591 
  def write(self, oprot):
9592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9594 
      return
9595 
    oprot.writeStructBegin('addSimilarItem_args')
9596 
    if self.itemId is not None:
9597 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9598 
      oprot.writeI64(self.itemId)
9599 
      oprot.writeFieldEnd()
9600 
    if self.catalogItemId is not None:
9601 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9602 
      oprot.writeI64(self.catalogItemId)
9603 
      oprot.writeFieldEnd()
9604 
    oprot.writeFieldStop()
9605 
    oprot.writeStructEnd()
9606 
 
9607 
  def validate(self):
9608 
    return
9609 
 
9610 
 
9611 
  def __repr__(self):
9612 
    L = ['%s=%r' % (key, value)
9613 
      for key, value in self.__dict__.iteritems()]
9614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9615 
 
9616 
  def __eq__(self, other):
9617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9618 
 
9619 
  def __ne__(self, other):
9620 
    return not (self == other)
9621 
 
9622 
class addSimilarItem_result:
9623 
  """
9624 
  Attributes:
9625 
   - success
9626 
   - cex
9627 
  """
9628 
 
9629 
  thrift_spec = (
9630 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9631 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9632 
  )
9633 
 
9634 
  def __init__(self, success=None, cex=None,):
9635 
    self.success = success
9636 
    self.cex = cex
9637 
 
9638 
  def read(self, iprot):
9639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9641 
      return
9642 
    iprot.readStructBegin()
9643 
    while True:
9644 
      (fname, ftype, fid) = iprot.readFieldBegin()
9645 
      if ftype == TType.STOP:
9646 
        break
9647 
      if fid == 0:
9648 
        if ftype == TType.STRUCT:
9649 
          self.success = Item()
9650 
          self.success.read(iprot)
9651 
        else:
9652 
          iprot.skip(ftype)
9653 
      elif fid == 1:
9654 
        if ftype == TType.STRUCT:
9655 
          self.cex = CatalogServiceException()
9656 
          self.cex.read(iprot)
9657 
        else:
9658 
          iprot.skip(ftype)
9659 
      else:
9660 
        iprot.skip(ftype)
9661 
      iprot.readFieldEnd()
9662 
    iprot.readStructEnd()
9663 
 
9664 
  def write(self, oprot):
9665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9667 
      return
9668 
    oprot.writeStructBegin('addSimilarItem_result')
9669 
    if self.success is not None:
9670 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9671 
      self.success.write(oprot)
9672 
      oprot.writeFieldEnd()
9673 
    if self.cex is not None:
9674 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9675 
      self.cex.write(oprot)
9676 
      oprot.writeFieldEnd()
9677 
    oprot.writeFieldStop()
9678 
    oprot.writeStructEnd()
9679 
 
9680 
  def validate(self):
9681 
    return
9682 
 
9683 
 
9684 
  def __repr__(self):
9685 
    L = ['%s=%r' % (key, value)
9686 
      for key, value in self.__dict__.iteritems()]
9687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9688 
 
9689 
  def __eq__(self, other):
9690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9691 
 
9692 
  def __ne__(self, other):
9693 
    return not (self == other)
9694 
 
6512 kshitij.so 9695 
class addTag_args:
9696 
  """
9697 
  Attributes:
9698 
   - displayName
9699 
   - itemId
9700 
  """
9701 
 
9702 
  thrift_spec = (
9703 
    None, # 0
9704 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9705 
    (2, TType.I64, 'itemId', None, None, ), # 2
9706 
  )
9707 
 
9708 
  def __init__(self, displayName=None, itemId=None,):
9709 
    self.displayName = displayName
9710 
    self.itemId = itemId
9711 
 
9712 
  def read(self, iprot):
9713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9715 
      return
9716 
    iprot.readStructBegin()
9717 
    while True:
9718 
      (fname, ftype, fid) = iprot.readFieldBegin()
9719 
      if ftype == TType.STOP:
9720 
        break
9721 
      if fid == 1:
9722 
        if ftype == TType.STRING:
9723 
          self.displayName = iprot.readString();
9724 
        else:
9725 
          iprot.skip(ftype)
9726 
      elif fid == 2:
9727 
        if ftype == TType.I64:
9728 
          self.itemId = iprot.readI64();
9729 
        else:
9730 
          iprot.skip(ftype)
9731 
      else:
9732 
        iprot.skip(ftype)
9733 
      iprot.readFieldEnd()
9734 
    iprot.readStructEnd()
9735 
 
9736 
  def write(self, oprot):
9737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9739 
      return
9740 
    oprot.writeStructBegin('addTag_args')
9741 
    if self.displayName is not None:
9742 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9743 
      oprot.writeString(self.displayName)
9744 
      oprot.writeFieldEnd()
9745 
    if self.itemId is not None:
9746 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9747 
      oprot.writeI64(self.itemId)
9748 
      oprot.writeFieldEnd()
9749 
    oprot.writeFieldStop()
9750 
    oprot.writeStructEnd()
9751 
 
9752 
  def validate(self):
9753 
    return
9754 
 
9755 
 
9756 
  def __repr__(self):
9757 
    L = ['%s=%r' % (key, value)
9758 
      for key, value in self.__dict__.iteritems()]
9759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9760 
 
9761 
  def __eq__(self, other):
9762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9763 
 
9764 
  def __ne__(self, other):
9765 
    return not (self == other)
9766 
 
9767 
class addTag_result:
9768 
  """
9769 
  Attributes:
9770 
   - success
9771 
  """
9772 
 
9773 
  thrift_spec = (
9774 
    (0, TType.BOOL, 'success', None, None, ), # 0
9775 
  )
9776 
 
9777 
  def __init__(self, success=None,):
9778 
    self.success = success
9779 
 
9780 
  def read(self, iprot):
9781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9783 
      return
9784 
    iprot.readStructBegin()
9785 
    while True:
9786 
      (fname, ftype, fid) = iprot.readFieldBegin()
9787 
      if ftype == TType.STOP:
9788 
        break
9789 
      if fid == 0:
9790 
        if ftype == TType.BOOL:
9791 
          self.success = iprot.readBool();
9792 
        else:
9793 
          iprot.skip(ftype)
9794 
      else:
9795 
        iprot.skip(ftype)
9796 
      iprot.readFieldEnd()
9797 
    iprot.readStructEnd()
9798 
 
9799 
  def write(self, oprot):
9800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9802 
      return
9803 
    oprot.writeStructBegin('addTag_result')
9804 
    if self.success is not None:
9805 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9806 
      oprot.writeBool(self.success)
9807 
      oprot.writeFieldEnd()
9808 
    oprot.writeFieldStop()
9809 
    oprot.writeStructEnd()
9810 
 
9811 
  def validate(self):
9812 
    return
9813 
 
9814 
 
9815 
  def __repr__(self):
9816 
    L = ['%s=%r' % (key, value)
9817 
      for key, value in self.__dict__.iteritems()]
9818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9819 
 
9820 
  def __eq__(self, other):
9821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9822 
 
9823 
  def __ne__(self, other):
9824 
    return not (self == other)
9825 
 
9826 
class deleteEntityTag_args:
9827 
  """
9828 
  Attributes:
9829 
   - displayName
9830 
   - itemId
9831 
  """
9832 
 
9833 
  thrift_spec = (
9834 
    None, # 0
9835 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9836 
    (2, TType.I64, 'itemId', None, None, ), # 2
9837 
  )
9838 
 
9839 
  def __init__(self, displayName=None, itemId=None,):
9840 
    self.displayName = displayName
9841 
    self.itemId = itemId
9842 
 
9843 
  def read(self, iprot):
9844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9846 
      return
9847 
    iprot.readStructBegin()
9848 
    while True:
9849 
      (fname, ftype, fid) = iprot.readFieldBegin()
9850 
      if ftype == TType.STOP:
9851 
        break
9852 
      if fid == 1:
9853 
        if ftype == TType.STRING:
9854 
          self.displayName = iprot.readString();
9855 
        else:
9856 
          iprot.skip(ftype)
9857 
      elif fid == 2:
9858 
        if ftype == TType.I64:
9859 
          self.itemId = iprot.readI64();
9860 
        else:
9861 
          iprot.skip(ftype)
9862 
      else:
9863 
        iprot.skip(ftype)
9864 
      iprot.readFieldEnd()
9865 
    iprot.readStructEnd()
9866 
 
9867 
  def write(self, oprot):
9868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9870 
      return
9871 
    oprot.writeStructBegin('deleteEntityTag_args')
9872 
    if self.displayName is not None:
9873 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9874 
      oprot.writeString(self.displayName)
9875 
      oprot.writeFieldEnd()
9876 
    if self.itemId is not None:
9877 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9878 
      oprot.writeI64(self.itemId)
9879 
      oprot.writeFieldEnd()
9880 
    oprot.writeFieldStop()
9881 
    oprot.writeStructEnd()
9882 
 
9883 
  def validate(self):
9884 
    return
9885 
 
9886 
 
9887 
  def __repr__(self):
9888 
    L = ['%s=%r' % (key, value)
9889 
      for key, value in self.__dict__.iteritems()]
9890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9891 
 
9892 
  def __eq__(self, other):
9893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9894 
 
9895 
  def __ne__(self, other):
9896 
    return not (self == other)
9897 
 
9898 
class deleteEntityTag_result:
9899 
  """
9900 
  Attributes:
9901 
   - success
9902 
  """
9903 
 
9904 
  thrift_spec = (
9905 
    (0, TType.BOOL, 'success', None, None, ), # 0
9906 
  )
9907 
 
9908 
  def __init__(self, success=None,):
9909 
    self.success = success
9910 
 
9911 
  def read(self, iprot):
9912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9914 
      return
9915 
    iprot.readStructBegin()
9916 
    while True:
9917 
      (fname, ftype, fid) = iprot.readFieldBegin()
9918 
      if ftype == TType.STOP:
9919 
        break
9920 
      if fid == 0:
9921 
        if ftype == TType.BOOL:
9922 
          self.success = iprot.readBool();
9923 
        else:
9924 
          iprot.skip(ftype)
9925 
      else:
9926 
        iprot.skip(ftype)
9927 
      iprot.readFieldEnd()
9928 
    iprot.readStructEnd()
9929 
 
9930 
  def write(self, oprot):
9931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9933 
      return
9934 
    oprot.writeStructBegin('deleteEntityTag_result')
9935 
    if self.success is not None:
9936 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9937 
      oprot.writeBool(self.success)
9938 
      oprot.writeFieldEnd()
9939 
    oprot.writeFieldStop()
9940 
    oprot.writeStructEnd()
9941 
 
9942 
  def validate(self):
9943 
    return
9944 
 
9945 
 
9946 
  def __repr__(self):
9947 
    L = ['%s=%r' % (key, value)
9948 
      for key, value in self.__dict__.iteritems()]
9949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9950 
 
9951 
  def __eq__(self, other):
9952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9953 
 
9954 
  def __ne__(self, other):
9955 
    return not (self == other)
9956 
 
9957 
class deleteTag_args:
9958 
  """
9959 
  Attributes:
9960 
   - displayName
9961 
  """
9962 
 
9963 
  thrift_spec = (
9964 
    None, # 0
9965 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9966 
  )
9967 
 
9968 
  def __init__(self, displayName=None,):
9969 
    self.displayName = displayName
9970 
 
9971 
  def read(self, iprot):
9972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9974 
      return
9975 
    iprot.readStructBegin()
9976 
    while True:
9977 
      (fname, ftype, fid) = iprot.readFieldBegin()
9978 
      if ftype == TType.STOP:
9979 
        break
9980 
      if fid == 1:
9981 
        if ftype == TType.STRING:
9982 
          self.displayName = iprot.readString();
9983 
        else:
9984 
          iprot.skip(ftype)
9985 
      else:
9986 
        iprot.skip(ftype)
9987 
      iprot.readFieldEnd()
9988 
    iprot.readStructEnd()
9989 
 
9990 
  def write(self, oprot):
9991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9993 
      return
9994 
    oprot.writeStructBegin('deleteTag_args')
9995 
    if self.displayName is not None:
9996 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9997 
      oprot.writeString(self.displayName)
9998 
      oprot.writeFieldEnd()
9999 
    oprot.writeFieldStop()
10000 
    oprot.writeStructEnd()
10001 
 
10002 
  def validate(self):
10003 
    return
10004 
 
10005 
 
10006 
  def __repr__(self):
10007 
    L = ['%s=%r' % (key, value)
10008 
      for key, value in self.__dict__.iteritems()]
10009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10010 
 
10011 
  def __eq__(self, other):
10012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10013 
 
10014 
  def __ne__(self, other):
10015 
    return not (self == other)
10016 
 
10017 
class deleteTag_result:
10018 
  """
10019 
  Attributes:
10020 
   - success
10021 
  """
10022 
 
10023 
  thrift_spec = (
10024 
    (0, TType.BOOL, 'success', None, None, ), # 0
10025 
  )
10026 
 
10027 
  def __init__(self, success=None,):
10028 
    self.success = success
10029 
 
10030 
  def read(self, iprot):
10031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10033 
      return
10034 
    iprot.readStructBegin()
10035 
    while True:
10036 
      (fname, ftype, fid) = iprot.readFieldBegin()
10037 
      if ftype == TType.STOP:
10038 
        break
10039 
      if fid == 0:
10040 
        if ftype == TType.BOOL:
10041 
          self.success = iprot.readBool();
10042 
        else:
10043 
          iprot.skip(ftype)
10044 
      else:
10045 
        iprot.skip(ftype)
10046 
      iprot.readFieldEnd()
10047 
    iprot.readStructEnd()
10048 
 
10049 
  def write(self, oprot):
10050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10052 
      return
10053 
    oprot.writeStructBegin('deleteTag_result')
10054 
    if self.success is not None:
10055 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10056 
      oprot.writeBool(self.success)
10057 
      oprot.writeFieldEnd()
10058 
    oprot.writeFieldStop()
10059 
    oprot.writeStructEnd()
10060 
 
10061 
  def validate(self):
10062 
    return
10063 
 
10064 
 
10065 
  def __repr__(self):
10066 
    L = ['%s=%r' % (key, value)
10067 
      for key, value in self.__dict__.iteritems()]
10068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10069 
 
10070 
  def __eq__(self, other):
10071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10072 
 
10073 
  def __ne__(self, other):
10074 
    return not (self == other)
10075 
 
10076 
class getAllTags_args:
10077 
 
10078 
  thrift_spec = (
10079 
  )
10080 
 
10081 
  def read(self, iprot):
10082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10084 
      return
10085 
    iprot.readStructBegin()
10086 
    while True:
10087 
      (fname, ftype, fid) = iprot.readFieldBegin()
10088 
      if ftype == TType.STOP:
10089 
        break
10090 
      else:
10091 
        iprot.skip(ftype)
10092 
      iprot.readFieldEnd()
10093 
    iprot.readStructEnd()
10094 
 
10095 
  def write(self, oprot):
10096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10098 
      return
10099 
    oprot.writeStructBegin('getAllTags_args')
10100 
    oprot.writeFieldStop()
10101 
    oprot.writeStructEnd()
10102 
 
10103 
  def validate(self):
10104 
    return
10105 
 
10106 
 
10107 
  def __repr__(self):
10108 
    L = ['%s=%r' % (key, value)
10109 
      for key, value in self.__dict__.iteritems()]
10110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10111 
 
10112 
  def __eq__(self, other):
10113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10114 
 
10115 
  def __ne__(self, other):
10116 
    return not (self == other)
10117 
 
10118 
class getAllTags_result:
10119 
  """
10120 
  Attributes:
10121 
   - success
10122 
  """
10123 
 
10124 
  thrift_spec = (
10125 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10126 
  )
10127 
 
10128 
  def __init__(self, success=None,):
10129 
    self.success = success
10130 
 
10131 
  def read(self, iprot):
10132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10134 
      return
10135 
    iprot.readStructBegin()
10136 
    while True:
10137 
      (fname, ftype, fid) = iprot.readFieldBegin()
10138 
      if ftype == TType.STOP:
10139 
        break
10140 
      if fid == 0:
10141 
        if ftype == TType.LIST:
10142 
          self.success = []
10143 
          (_etype138, _size135) = iprot.readListBegin()
10144 
          for _i139 in xrange(_size135):
10145 
            _elem140 = iprot.readString();
10146 
            self.success.append(_elem140)
10147 
          iprot.readListEnd()
10148 
        else:
10149 
          iprot.skip(ftype)
10150 
      else:
10151 
        iprot.skip(ftype)
10152 
      iprot.readFieldEnd()
10153 
    iprot.readStructEnd()
10154 
 
10155 
  def write(self, oprot):
10156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10158 
      return
10159 
    oprot.writeStructBegin('getAllTags_result')
10160 
    if self.success is not None:
10161 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10162 
      oprot.writeListBegin(TType.STRING, len(self.success))
10163 
      for iter141 in self.success:
10164 
        oprot.writeString(iter141)
10165 
      oprot.writeListEnd()
10166 
      oprot.writeFieldEnd()
10167 
    oprot.writeFieldStop()
10168 
    oprot.writeStructEnd()
10169 
 
10170 
  def validate(self):
10171 
    return
10172 
 
10173 
 
10174 
  def __repr__(self):
10175 
    L = ['%s=%r' % (key, value)
10176 
      for key, value in self.__dict__.iteritems()]
10177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10178 
 
10179 
  def __eq__(self, other):
10180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10181 
 
10182 
  def __ne__(self, other):
10183 
    return not (self == other)
10184 
 
10185 
class getAllEntitiesByTagName_args:
10186 
  """
10187 
  Attributes:
10188 
   - displayName
10189 
  """
10190 
 
10191 
  thrift_spec = (
10192 
    None, # 0
10193 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10194 
  )
10195 
 
10196 
  def __init__(self, displayName=None,):
10197 
    self.displayName = displayName
10198 
 
10199 
  def read(self, iprot):
10200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10202 
      return
10203 
    iprot.readStructBegin()
10204 
    while True:
10205 
      (fname, ftype, fid) = iprot.readFieldBegin()
10206 
      if ftype == TType.STOP:
10207 
        break
10208 
      if fid == 1:
10209 
        if ftype == TType.STRING:
10210 
          self.displayName = iprot.readString();
10211 
        else:
10212 
          iprot.skip(ftype)
10213 
      else:
10214 
        iprot.skip(ftype)
10215 
      iprot.readFieldEnd()
10216 
    iprot.readStructEnd()
10217 
 
10218 
  def write(self, oprot):
10219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10221 
      return
10222 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10223 
    if self.displayName is not None:
10224 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10225 
      oprot.writeString(self.displayName)
10226 
      oprot.writeFieldEnd()
10227 
    oprot.writeFieldStop()
10228 
    oprot.writeStructEnd()
10229 
 
10230 
  def validate(self):
10231 
    return
10232 
 
10233 
 
10234 
  def __repr__(self):
10235 
    L = ['%s=%r' % (key, value)
10236 
      for key, value in self.__dict__.iteritems()]
10237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10238 
 
10239 
  def __eq__(self, other):
10240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10241 
 
10242 
  def __ne__(self, other):
10243 
    return not (self == other)
10244 
 
10245 
class getAllEntitiesByTagName_result:
10246 
  """
10247 
  Attributes:
10248 
   - success
10249 
  """
10250 
 
10251 
  thrift_spec = (
10252 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10253 
  )
10254 
 
10255 
  def __init__(self, success=None,):
10256 
    self.success = success
10257 
 
10258 
  def read(self, iprot):
10259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10261 
      return
10262 
    iprot.readStructBegin()
10263 
    while True:
10264 
      (fname, ftype, fid) = iprot.readFieldBegin()
10265 
      if ftype == TType.STOP:
10266 
        break
10267 
      if fid == 0:
10268 
        if ftype == TType.LIST:
10269 
          self.success = []
10270 
          (_etype145, _size142) = iprot.readListBegin()
10271 
          for _i146 in xrange(_size142):
10272 
            _elem147 = iprot.readI64();
10273 
            self.success.append(_elem147)
10274 
          iprot.readListEnd()
10275 
        else:
10276 
          iprot.skip(ftype)
10277 
      else:
10278 
        iprot.skip(ftype)
10279 
      iprot.readFieldEnd()
10280 
    iprot.readStructEnd()
10281 
 
10282 
  def write(self, oprot):
10283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10285 
      return
10286 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10287 
    if self.success is not None:
10288 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10289 
      oprot.writeListBegin(TType.I64, len(self.success))
10290 
      for iter148 in self.success:
10291 
        oprot.writeI64(iter148)
10292 
      oprot.writeListEnd()
10293 
      oprot.writeFieldEnd()
10294 
    oprot.writeFieldStop()
10295 
    oprot.writeStructEnd()
10296 
 
10297 
  def validate(self):
10298 
    return
10299 
 
10300 
 
10301 
  def __repr__(self):
10302 
    L = ['%s=%r' % (key, value)
10303 
      for key, value in self.__dict__.iteritems()]
10304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10305 
 
10306 
  def __eq__(self, other):
10307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10308 
 
10309 
  def __ne__(self, other):
10310 
    return not (self == other)
10311 
 
6845 amit.gupta 10312 
class getAllEntityTags_args:
10313 
 
10314 
  thrift_spec = (
10315 
  )
10316 
 
10317 
  def read(self, iprot):
10318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10320 
      return
10321 
    iprot.readStructBegin()
10322 
    while True:
10323 
      (fname, ftype, fid) = iprot.readFieldBegin()
10324 
      if ftype == TType.STOP:
10325 
        break
10326 
      else:
10327 
        iprot.skip(ftype)
10328 
      iprot.readFieldEnd()
10329 
    iprot.readStructEnd()
10330 
 
10331 
  def write(self, oprot):
10332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10334 
      return
10335 
    oprot.writeStructBegin('getAllEntityTags_args')
10336 
    oprot.writeFieldStop()
10337 
    oprot.writeStructEnd()
10338 
 
10339 
  def validate(self):
10340 
    return
10341 
 
10342 
 
10343 
  def __repr__(self):
10344 
    L = ['%s=%r' % (key, value)
10345 
      for key, value in self.__dict__.iteritems()]
10346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10347 
 
10348 
  def __eq__(self, other):
10349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10350 
 
10351 
  def __ne__(self, other):
10352 
    return not (self == other)
10353 
 
10354 
class getAllEntityTags_result:
10355 
  """
10356 
  Attributes:
10357 
   - success
10358 
  """
10359 
 
10360 
  thrift_spec = (
10361 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10362 
  )
10363 
 
10364 
  def __init__(self, success=None,):
10365 
    self.success = success
10366 
 
10367 
  def read(self, iprot):
10368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10370 
      return
10371 
    iprot.readStructBegin()
10372 
    while True:
10373 
      (fname, ftype, fid) = iprot.readFieldBegin()
10374 
      if ftype == TType.STOP:
10375 
        break
10376 
      if fid == 0:
10377 
        if ftype == TType.MAP:
10378 
          self.success = {}
10379 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10380 
          for _i153 in xrange(_size149):
10381 
            _key154 = iprot.readI64();
10382 
            _val155 = []
10383 
            (_etype159, _size156) = iprot.readListBegin()
10384 
            for _i160 in xrange(_size156):
10385 
              _elem161 = iprot.readString();
10386 
              _val155.append(_elem161)
10387 
            iprot.readListEnd()
10388 
            self.success[_key154] = _val155
10389 
          iprot.readMapEnd()
10390 
        else:
10391 
          iprot.skip(ftype)
10392 
      else:
10393 
        iprot.skip(ftype)
10394 
      iprot.readFieldEnd()
10395 
    iprot.readStructEnd()
10396 
 
10397 
  def write(self, oprot):
10398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10400 
      return
10401 
    oprot.writeStructBegin('getAllEntityTags_result')
10402 
    if self.success is not None:
10403 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10404 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10405 
      for kiter162,viter163 in self.success.items():
10406 
        oprot.writeI64(kiter162)
10407 
        oprot.writeListBegin(TType.STRING, len(viter163))
10408 
        for iter164 in viter163:
10409 
          oprot.writeString(iter164)
10410 
        oprot.writeListEnd()
10411 
      oprot.writeMapEnd()
10412 
      oprot.writeFieldEnd()
10413 
    oprot.writeFieldStop()
10414 
    oprot.writeStructEnd()
10415 
 
10416 
  def validate(self):
10417 
    return
10418 
 
10419 
 
10420 
  def __repr__(self):
10421 
    L = ['%s=%r' % (key, value)
10422 
      for key, value in self.__dict__.iteritems()]
10423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10424 
 
10425 
  def __eq__(self, other):
10426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10427 
 
10428 
  def __ne__(self, other):
10429 
    return not (self == other)
10430 
 
6850 kshitij.so 10431 
class addBanner_args:
10432 
  """
10433 
  Attributes:
10434 
   - bannerName
10435 
   - imageName
10436 
   - link
10437 
   - priority
10438 
   - isActive
10439 
   - hasMap
10440 
  """
10441 
 
10442 
  thrift_spec = (
10443 
    None, # 0
10444 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10445 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10446 
    (3, TType.STRING, 'link', None, None, ), # 3
10447 
    (4, TType.I64, 'priority', None, None, ), # 4
10448 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10449 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10450 
  )
10451 
 
10452 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10453 
    self.bannerName = bannerName
10454 
    self.imageName = imageName
10455 
    self.link = link
10456 
    self.priority = priority
10457 
    self.isActive = isActive
10458 
    self.hasMap = hasMap
10459 
 
10460 
  def read(self, iprot):
10461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10463 
      return
10464 
    iprot.readStructBegin()
10465 
    while True:
10466 
      (fname, ftype, fid) = iprot.readFieldBegin()
10467 
      if ftype == TType.STOP:
10468 
        break
10469 
      if fid == 1:
10470 
        if ftype == TType.STRING:
10471 
          self.bannerName = iprot.readString();
10472 
        else:
10473 
          iprot.skip(ftype)
10474 
      elif fid == 2:
10475 
        if ftype == TType.STRING:
10476 
          self.imageName = iprot.readString();
10477 
        else:
10478 
          iprot.skip(ftype)
10479 
      elif fid == 3:
10480 
        if ftype == TType.STRING:
10481 
          self.link = iprot.readString();
10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      elif fid == 4:
10485 
        if ftype == TType.I64:
10486 
          self.priority = iprot.readI64();
10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 5:
10490 
        if ftype == TType.BOOL:
10491 
          self.isActive = iprot.readBool();
10492 
        else:
10493 
          iprot.skip(ftype)
10494 
      elif fid == 6:
10495 
        if ftype == TType.BOOL:
10496 
          self.hasMap = iprot.readBool();
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      else:
10500 
        iprot.skip(ftype)
10501 
      iprot.readFieldEnd()
10502 
    iprot.readStructEnd()
10503 
 
10504 
  def write(self, oprot):
10505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10507 
      return
10508 
    oprot.writeStructBegin('addBanner_args')
10509 
    if self.bannerName is not None:
10510 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10511 
      oprot.writeString(self.bannerName)
10512 
      oprot.writeFieldEnd()
10513 
    if self.imageName is not None:
10514 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10515 
      oprot.writeString(self.imageName)
10516 
      oprot.writeFieldEnd()
10517 
    if self.link is not None:
10518 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10519 
      oprot.writeString(self.link)
10520 
      oprot.writeFieldEnd()
10521 
    if self.priority is not None:
10522 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10523 
      oprot.writeI64(self.priority)
10524 
      oprot.writeFieldEnd()
10525 
    if self.isActive is not None:
10526 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10527 
      oprot.writeBool(self.isActive)
10528 
      oprot.writeFieldEnd()
10529 
    if self.hasMap is not None:
10530 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10531 
      oprot.writeBool(self.hasMap)
10532 
      oprot.writeFieldEnd()
10533 
    oprot.writeFieldStop()
10534 
    oprot.writeStructEnd()
10535 
 
10536 
  def validate(self):
10537 
    return
10538 
 
10539 
 
10540 
  def __repr__(self):
10541 
    L = ['%s=%r' % (key, value)
10542 
      for key, value in self.__dict__.iteritems()]
10543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10544 
 
10545 
  def __eq__(self, other):
10546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10547 
 
10548 
  def __ne__(self, other):
10549 
    return not (self == other)
10550 
 
10551 
class addBanner_result:
10552 
  """
10553 
  Attributes:
10554 
   - success
10555 
  """
10556 
 
10557 
  thrift_spec = (
10558 
    (0, TType.BOOL, 'success', None, None, ), # 0
10559 
  )
10560 
 
10561 
  def __init__(self, success=None,):
10562 
    self.success = success
10563 
 
10564 
  def read(self, iprot):
10565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10567 
      return
10568 
    iprot.readStructBegin()
10569 
    while True:
10570 
      (fname, ftype, fid) = iprot.readFieldBegin()
10571 
      if ftype == TType.STOP:
10572 
        break
10573 
      if fid == 0:
10574 
        if ftype == TType.BOOL:
10575 
          self.success = iprot.readBool();
10576 
        else:
10577 
          iprot.skip(ftype)
10578 
      else:
10579 
        iprot.skip(ftype)
10580 
      iprot.readFieldEnd()
10581 
    iprot.readStructEnd()
10582 
 
10583 
  def write(self, oprot):
10584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10586 
      return
10587 
    oprot.writeStructBegin('addBanner_result')
10588 
    if self.success is not None:
10589 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10590 
      oprot.writeBool(self.success)
10591 
      oprot.writeFieldEnd()
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
10610 
class getAllBanners_args:
10611 
 
10612 
  thrift_spec = (
10613 
  )
10614 
 
10615 
  def read(self, iprot):
10616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10618 
      return
10619 
    iprot.readStructBegin()
10620 
    while True:
10621 
      (fname, ftype, fid) = iprot.readFieldBegin()
10622 
      if ftype == TType.STOP:
10623 
        break
10624 
      else:
10625 
        iprot.skip(ftype)
10626 
      iprot.readFieldEnd()
10627 
    iprot.readStructEnd()
10628 
 
10629 
  def write(self, oprot):
10630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10632 
      return
10633 
    oprot.writeStructBegin('getAllBanners_args')
10634 
    oprot.writeFieldStop()
10635 
    oprot.writeStructEnd()
10636 
 
10637 
  def validate(self):
10638 
    return
10639 
 
10640 
 
10641 
  def __repr__(self):
10642 
    L = ['%s=%r' % (key, value)
10643 
      for key, value in self.__dict__.iteritems()]
10644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10645 
 
10646 
  def __eq__(self, other):
10647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10648 
 
10649 
  def __ne__(self, other):
10650 
    return not (self == other)
10651 
 
10652 
class getAllBanners_result:
10653 
  """
10654 
  Attributes:
10655 
   - success
10656 
  """
10657 
 
10658 
  thrift_spec = (
10659 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10660 
  )
10661 
 
10662 
  def __init__(self, success=None,):
10663 
    self.success = success
10664 
 
10665 
  def read(self, iprot):
10666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10668 
      return
10669 
    iprot.readStructBegin()
10670 
    while True:
10671 
      (fname, ftype, fid) = iprot.readFieldBegin()
10672 
      if ftype == TType.STOP:
10673 
        break
10674 
      if fid == 0:
10675 
        if ftype == TType.LIST:
10676 
          self.success = []
10677 
          (_etype168, _size165) = iprot.readListBegin()
10678 
          for _i169 in xrange(_size165):
10679 
            _elem170 = iprot.readString();
10680 
            self.success.append(_elem170)
10681 
          iprot.readListEnd()
10682 
        else:
10683 
          iprot.skip(ftype)
10684 
      else:
10685 
        iprot.skip(ftype)
10686 
      iprot.readFieldEnd()
10687 
    iprot.readStructEnd()
10688 
 
10689 
  def write(self, oprot):
10690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10692 
      return
10693 
    oprot.writeStructBegin('getAllBanners_result')
10694 
    if self.success is not None:
10695 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10696 
      oprot.writeListBegin(TType.STRING, len(self.success))
10697 
      for iter171 in self.success:
10698 
        oprot.writeString(iter171)
10699 
      oprot.writeListEnd()
10700 
      oprot.writeFieldEnd()
10701 
    oprot.writeFieldStop()
10702 
    oprot.writeStructEnd()
10703 
 
10704 
  def validate(self):
10705 
    return
10706 
 
10707 
 
10708 
  def __repr__(self):
10709 
    L = ['%s=%r' % (key, value)
10710 
      for key, value in self.__dict__.iteritems()]
10711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10712 
 
10713 
  def __eq__(self, other):
10714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10715 
 
10716 
  def __ne__(self, other):
10717 
    return not (self == other)
10718 
 
10719 
class deleteBanner_args:
10720 
  """
10721 
  Attributes:
10722 
   - bannerName
10723 
  """
10724 
 
10725 
  thrift_spec = (
10726 
    None, # 0
10727 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10728 
  )
10729 
 
10730 
  def __init__(self, bannerName=None,):
10731 
    self.bannerName = bannerName
10732 
 
10733 
  def read(self, iprot):
10734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10736 
      return
10737 
    iprot.readStructBegin()
10738 
    while True:
10739 
      (fname, ftype, fid) = iprot.readFieldBegin()
10740 
      if ftype == TType.STOP:
10741 
        break
10742 
      if fid == 1:
10743 
        if ftype == TType.STRING:
10744 
          self.bannerName = iprot.readString();
10745 
        else:
10746 
          iprot.skip(ftype)
10747 
      else:
10748 
        iprot.skip(ftype)
10749 
      iprot.readFieldEnd()
10750 
    iprot.readStructEnd()
10751 
 
10752 
  def write(self, oprot):
10753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10755 
      return
10756 
    oprot.writeStructBegin('deleteBanner_args')
10757 
    if self.bannerName is not None:
10758 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10759 
      oprot.writeString(self.bannerName)
10760 
      oprot.writeFieldEnd()
10761 
    oprot.writeFieldStop()
10762 
    oprot.writeStructEnd()
10763 
 
10764 
  def validate(self):
10765 
    return
10766 
 
10767 
 
10768 
  def __repr__(self):
10769 
    L = ['%s=%r' % (key, value)
10770 
      for key, value in self.__dict__.iteritems()]
10771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10772 
 
10773 
  def __eq__(self, other):
10774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10775 
 
10776 
  def __ne__(self, other):
10777 
    return not (self == other)
10778 
 
10779 
class deleteBanner_result:
10780 
  """
10781 
  Attributes:
10782 
   - success
10783 
  """
10784 
 
10785 
  thrift_spec = (
10786 
    (0, TType.BOOL, 'success', None, None, ), # 0
10787 
  )
10788 
 
10789 
  def __init__(self, success=None,):
10790 
    self.success = success
10791 
 
10792 
  def read(self, iprot):
10793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10795 
      return
10796 
    iprot.readStructBegin()
10797 
    while True:
10798 
      (fname, ftype, fid) = iprot.readFieldBegin()
10799 
      if ftype == TType.STOP:
10800 
        break
10801 
      if fid == 0:
10802 
        if ftype == TType.BOOL:
10803 
          self.success = iprot.readBool();
10804 
        else:
10805 
          iprot.skip(ftype)
10806 
      else:
10807 
        iprot.skip(ftype)
10808 
      iprot.readFieldEnd()
10809 
    iprot.readStructEnd()
10810 
 
10811 
  def write(self, oprot):
10812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10814 
      return
10815 
    oprot.writeStructBegin('deleteBanner_result')
10816 
    if self.success is not None:
10817 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10818 
      oprot.writeBool(self.success)
10819 
      oprot.writeFieldEnd()
10820 
    oprot.writeFieldStop()
10821 
    oprot.writeStructEnd()
10822 
 
10823 
  def validate(self):
10824 
    return
10825 
 
10826 
 
10827 
  def __repr__(self):
10828 
    L = ['%s=%r' % (key, value)
10829 
      for key, value in self.__dict__.iteritems()]
10830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10831 
 
10832 
  def __eq__(self, other):
10833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10834 
 
10835 
  def __ne__(self, other):
10836 
    return not (self == other)
10837 
 
10838 
class getBannerDetails_args:
10839 
  """
10840 
  Attributes:
10841 
   - bannerName
10842 
  """
10843 
 
10844 
  thrift_spec = (
10845 
    None, # 0
10846 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10847 
  )
10848 
 
10849 
  def __init__(self, bannerName=None,):
10850 
    self.bannerName = bannerName
10851 
 
10852 
  def read(self, iprot):
10853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10855 
      return
10856 
    iprot.readStructBegin()
10857 
    while True:
10858 
      (fname, ftype, fid) = iprot.readFieldBegin()
10859 
      if ftype == TType.STOP:
10860 
        break
10861 
      if fid == 1:
10862 
        if ftype == TType.STRING:
10863 
          self.bannerName = iprot.readString();
10864 
        else:
10865 
          iprot.skip(ftype)
10866 
      else:
10867 
        iprot.skip(ftype)
10868 
      iprot.readFieldEnd()
10869 
    iprot.readStructEnd()
10870 
 
10871 
  def write(self, oprot):
10872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10874 
      return
10875 
    oprot.writeStructBegin('getBannerDetails_args')
10876 
    if self.bannerName is not None:
10877 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10878 
      oprot.writeString(self.bannerName)
10879 
      oprot.writeFieldEnd()
10880 
    oprot.writeFieldStop()
10881 
    oprot.writeStructEnd()
10882 
 
10883 
  def validate(self):
10884 
    return
10885 
 
10886 
 
10887 
  def __repr__(self):
10888 
    L = ['%s=%r' % (key, value)
10889 
      for key, value in self.__dict__.iteritems()]
10890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10891 
 
10892 
  def __eq__(self, other):
10893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10894 
 
10895 
  def __ne__(self, other):
10896 
    return not (self == other)
10897 
 
10898 
class getBannerDetails_result:
10899 
  """
10900 
  Attributes:
10901 
   - success
10902 
  """
10903 
 
10904 
  thrift_spec = (
10905 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10906 
  )
10907 
 
10908 
  def __init__(self, success=None,):
10909 
    self.success = success
10910 
 
10911 
  def read(self, iprot):
10912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10914 
      return
10915 
    iprot.readStructBegin()
10916 
    while True:
10917 
      (fname, ftype, fid) = iprot.readFieldBegin()
10918 
      if ftype == TType.STOP:
10919 
        break
10920 
      if fid == 0:
10921 
        if ftype == TType.STRUCT:
10922 
          self.success = Banner()
10923 
          self.success.read(iprot)
10924 
        else:
10925 
          iprot.skip(ftype)
10926 
      else:
10927 
        iprot.skip(ftype)
10928 
      iprot.readFieldEnd()
10929 
    iprot.readStructEnd()
10930 
 
10931 
  def write(self, oprot):
10932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10934 
      return
10935 
    oprot.writeStructBegin('getBannerDetails_result')
10936 
    if self.success is not None:
10937 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10938 
      self.success.write(oprot)
10939 
      oprot.writeFieldEnd()
10940 
    oprot.writeFieldStop()
10941 
    oprot.writeStructEnd()
10942 
 
10943 
  def validate(self):
10944 
    return
10945 
 
10946 
 
10947 
  def __repr__(self):
10948 
    L = ['%s=%r' % (key, value)
10949 
      for key, value in self.__dict__.iteritems()]
10950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10951 
 
10952 
  def __eq__(self, other):
10953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10954 
 
10955 
  def __ne__(self, other):
10956 
    return not (self == other)
10957 
 
10958 
class getActiveBanners_args:
10959 
 
10960 
  thrift_spec = (
10961 
  )
10962 
 
10963 
  def read(self, iprot):
10964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10966 
      return
10967 
    iprot.readStructBegin()
10968 
    while True:
10969 
      (fname, ftype, fid) = iprot.readFieldBegin()
10970 
      if ftype == TType.STOP:
10971 
        break
10972 
      else:
10973 
        iprot.skip(ftype)
10974 
      iprot.readFieldEnd()
10975 
    iprot.readStructEnd()
10976 
 
10977 
  def write(self, oprot):
10978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10980 
      return
10981 
    oprot.writeStructBegin('getActiveBanners_args')
10982 
    oprot.writeFieldStop()
10983 
    oprot.writeStructEnd()
10984 
 
10985 
  def validate(self):
10986 
    return
10987 
 
10988 
 
10989 
  def __repr__(self):
10990 
    L = ['%s=%r' % (key, value)
10991 
      for key, value in self.__dict__.iteritems()]
10992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10993 
 
10994 
  def __eq__(self, other):
10995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10996 
 
10997 
  def __ne__(self, other):
10998 
    return not (self == other)
10999 
 
11000 
class getActiveBanners_result:
11001 
  """
11002 
  Attributes:
11003 
   - success
11004 
  """
11005 
 
11006 
  thrift_spec = (
11007 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11008 
  )
11009 
 
11010 
  def __init__(self, success=None,):
11011 
    self.success = success
11012 
 
11013 
  def read(self, iprot):
11014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11016 
      return
11017 
    iprot.readStructBegin()
11018 
    while True:
11019 
      (fname, ftype, fid) = iprot.readFieldBegin()
11020 
      if ftype == TType.STOP:
11021 
        break
11022 
      if fid == 0:
11023 
        if ftype == TType.LIST:
11024 
          self.success = []
11025 
          (_etype175, _size172) = iprot.readListBegin()
11026 
          for _i176 in xrange(_size172):
11027 
            _elem177 = Banner()
11028 
            _elem177.read(iprot)
11029 
            self.success.append(_elem177)
11030 
          iprot.readListEnd()
11031 
        else:
11032 
          iprot.skip(ftype)
11033 
      else:
11034 
        iprot.skip(ftype)
11035 
      iprot.readFieldEnd()
11036 
    iprot.readStructEnd()
11037 
 
11038 
  def write(self, oprot):
11039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11041 
      return
11042 
    oprot.writeStructBegin('getActiveBanners_result')
11043 
    if self.success is not None:
11044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11046 
      for iter178 in self.success:
11047 
        iter178.write(oprot)
11048 
      oprot.writeListEnd()
11049 
      oprot.writeFieldEnd()
11050 
    oprot.writeFieldStop()
11051 
    oprot.writeStructEnd()
11052 
 
11053 
  def validate(self):
11054 
    return
11055 
 
11056 
 
11057 
  def __repr__(self):
11058 
    L = ['%s=%r' % (key, value)
11059 
      for key, value in self.__dict__.iteritems()]
11060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11061 
 
11062 
  def __eq__(self, other):
11063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11064 
 
11065 
  def __ne__(self, other):
11066 
    return not (self == other)
11067 
 
6849 kshitij.so 11068 
class addBannerMap_args:
11069 
  """
11070 
  Attributes:
11071 
   - bannerName
11072 
   - mapLink
11073 
   - coordinates
11074 
  """
11075 
 
11076 
  thrift_spec = (
11077 
    None, # 0
11078 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11079 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11080 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11081 
  )
11082 
 
11083 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11084 
    self.bannerName = bannerName
11085 
    self.mapLink = mapLink
11086 
    self.coordinates = coordinates
11087 
 
11088 
  def read(self, iprot):
11089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11091 
      return
11092 
    iprot.readStructBegin()
11093 
    while True:
11094 
      (fname, ftype, fid) = iprot.readFieldBegin()
11095 
      if ftype == TType.STOP:
11096 
        break
11097 
      if fid == 1:
11098 
        if ftype == TType.STRING:
11099 
          self.bannerName = iprot.readString();
11100 
        else:
11101 
          iprot.skip(ftype)
11102 
      elif fid == 2:
11103 
        if ftype == TType.STRING:
11104 
          self.mapLink = iprot.readString();
11105 
        else:
11106 
          iprot.skip(ftype)
11107 
      elif fid == 3:
11108 
        if ftype == TType.STRING:
11109 
          self.coordinates = iprot.readString();
11110 
        else:
11111 
          iprot.skip(ftype)
11112 
      else:
11113 
        iprot.skip(ftype)
11114 
      iprot.readFieldEnd()
11115 
    iprot.readStructEnd()
11116 
 
11117 
  def write(self, oprot):
11118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11120 
      return
11121 
    oprot.writeStructBegin('addBannerMap_args')
11122 
    if self.bannerName is not None:
11123 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11124 
      oprot.writeString(self.bannerName)
11125 
      oprot.writeFieldEnd()
11126 
    if self.mapLink is not None:
11127 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11128 
      oprot.writeString(self.mapLink)
11129 
      oprot.writeFieldEnd()
11130 
    if self.coordinates is not None:
11131 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11132 
      oprot.writeString(self.coordinates)
11133 
      oprot.writeFieldEnd()
11134 
    oprot.writeFieldStop()
11135 
    oprot.writeStructEnd()
11136 
 
11137 
  def validate(self):
11138 
    return
11139 
 
11140 
 
11141 
  def __repr__(self):
11142 
    L = ['%s=%r' % (key, value)
11143 
      for key, value in self.__dict__.iteritems()]
11144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11145 
 
11146 
  def __eq__(self, other):
11147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11148 
 
11149 
  def __ne__(self, other):
11150 
    return not (self == other)
11151 
 
11152 
class addBannerMap_result:
11153 
  """
11154 
  Attributes:
11155 
   - success
11156 
  """
11157 
 
11158 
  thrift_spec = (
11159 
    (0, TType.BOOL, 'success', None, None, ), # 0
11160 
  )
11161 
 
11162 
  def __init__(self, success=None,):
11163 
    self.success = success
11164 
 
11165 
  def read(self, iprot):
11166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11168 
      return
11169 
    iprot.readStructBegin()
11170 
    while True:
11171 
      (fname, ftype, fid) = iprot.readFieldBegin()
11172 
      if ftype == TType.STOP:
11173 
        break
11174 
      if fid == 0:
11175 
        if ftype == TType.BOOL:
11176 
          self.success = iprot.readBool();
11177 
        else:
11178 
          iprot.skip(ftype)
11179 
      else:
11180 
        iprot.skip(ftype)
11181 
      iprot.readFieldEnd()
11182 
    iprot.readStructEnd()
11183 
 
11184 
  def write(self, oprot):
11185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11187 
      return
11188 
    oprot.writeStructBegin('addBannerMap_result')
11189 
    if self.success is not None:
11190 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11191 
      oprot.writeBool(self.success)
11192 
      oprot.writeFieldEnd()
11193 
    oprot.writeFieldStop()
11194 
    oprot.writeStructEnd()
11195 
 
11196 
  def validate(self):
11197 
    return
11198 
 
11199 
 
11200 
  def __repr__(self):
11201 
    L = ['%s=%r' % (key, value)
11202 
      for key, value in self.__dict__.iteritems()]
11203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11204 
 
11205 
  def __eq__(self, other):
11206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11207 
 
11208 
  def __ne__(self, other):
11209 
    return not (self == other)
11210 
 
11211 
class deleteBannerMap_args:
11212 
  """
11213 
  Attributes:
11214 
   - bannerName
11215 
  """
11216 
 
11217 
  thrift_spec = (
11218 
    None, # 0
11219 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11220 
  )
11221 
 
11222 
  def __init__(self, bannerName=None,):
11223 
    self.bannerName = bannerName
11224 
 
11225 
  def read(self, iprot):
11226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11228 
      return
11229 
    iprot.readStructBegin()
11230 
    while True:
11231 
      (fname, ftype, fid) = iprot.readFieldBegin()
11232 
      if ftype == TType.STOP:
11233 
        break
11234 
      if fid == 1:
11235 
        if ftype == TType.STRING:
11236 
          self.bannerName = iprot.readString();
11237 
        else:
11238 
          iprot.skip(ftype)
11239 
      else:
11240 
        iprot.skip(ftype)
11241 
      iprot.readFieldEnd()
11242 
    iprot.readStructEnd()
11243 
 
11244 
  def write(self, oprot):
11245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11247 
      return
11248 
    oprot.writeStructBegin('deleteBannerMap_args')
11249 
    if self.bannerName is not None:
11250 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11251 
      oprot.writeString(self.bannerName)
11252 
      oprot.writeFieldEnd()
11253 
    oprot.writeFieldStop()
11254 
    oprot.writeStructEnd()
11255 
 
11256 
  def validate(self):
11257 
    return
11258 
 
11259 
 
11260 
  def __repr__(self):
11261 
    L = ['%s=%r' % (key, value)
11262 
      for key, value in self.__dict__.iteritems()]
11263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11264 
 
11265 
  def __eq__(self, other):
11266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11267 
 
11268 
  def __ne__(self, other):
11269 
    return not (self == other)
11270 
 
11271 
class deleteBannerMap_result:
11272 
  """
11273 
  Attributes:
11274 
   - success
11275 
  """
11276 
 
11277 
  thrift_spec = (
11278 
    (0, TType.BOOL, 'success', None, None, ), # 0
11279 
  )
11280 
 
11281 
  def __init__(self, success=None,):
11282 
    self.success = success
11283 
 
11284 
  def read(self, iprot):
11285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11287 
      return
11288 
    iprot.readStructBegin()
11289 
    while True:
11290 
      (fname, ftype, fid) = iprot.readFieldBegin()
11291 
      if ftype == TType.STOP:
11292 
        break
11293 
      if fid == 0:
11294 
        if ftype == TType.BOOL:
11295 
          self.success = iprot.readBool();
11296 
        else:
11297 
          iprot.skip(ftype)
11298 
      else:
11299 
        iprot.skip(ftype)
11300 
      iprot.readFieldEnd()
11301 
    iprot.readStructEnd()
11302 
 
11303 
  def write(self, oprot):
11304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11306 
      return
11307 
    oprot.writeStructBegin('deleteBannerMap_result')
11308 
    if self.success is not None:
11309 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11310 
      oprot.writeBool(self.success)
11311 
      oprot.writeFieldEnd()
11312 
    oprot.writeFieldStop()
11313 
    oprot.writeStructEnd()
11314 
 
11315 
  def validate(self):
11316 
    return
11317 
 
11318 
 
11319 
  def __repr__(self):
11320 
    L = ['%s=%r' % (key, value)
11321 
      for key, value in self.__dict__.iteritems()]
11322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11323 
 
11324 
  def __eq__(self, other):
11325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11326 
 
11327 
  def __ne__(self, other):
11328 
    return not (self == other)
11329 
 
11330 
class getBannerMapDetails_args:
11331 
  """
11332 
  Attributes:
11333 
   - bannerName
11334 
  """
11335 
 
11336 
  thrift_spec = (
11337 
    None, # 0
11338 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11339 
  )
11340 
 
11341 
  def __init__(self, bannerName=None,):
11342 
    self.bannerName = bannerName
11343 
 
11344 
  def read(self, iprot):
11345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11347 
      return
11348 
    iprot.readStructBegin()
11349 
    while True:
11350 
      (fname, ftype, fid) = iprot.readFieldBegin()
11351 
      if ftype == TType.STOP:
11352 
        break
11353 
      if fid == 1:
11354 
        if ftype == TType.STRING:
11355 
          self.bannerName = iprot.readString();
11356 
        else:
11357 
          iprot.skip(ftype)
11358 
      else:
11359 
        iprot.skip(ftype)
11360 
      iprot.readFieldEnd()
11361 
    iprot.readStructEnd()
11362 
 
11363 
  def write(self, oprot):
11364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11366 
      return
11367 
    oprot.writeStructBegin('getBannerMapDetails_args')
11368 
    if self.bannerName is not None:
11369 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11370 
      oprot.writeString(self.bannerName)
11371 
      oprot.writeFieldEnd()
11372 
    oprot.writeFieldStop()
11373 
    oprot.writeStructEnd()
11374 
 
11375 
  def validate(self):
11376 
    return
11377 
 
11378 
 
11379 
  def __repr__(self):
11380 
    L = ['%s=%r' % (key, value)
11381 
      for key, value in self.__dict__.iteritems()]
11382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11383 
 
11384 
  def __eq__(self, other):
11385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11386 
 
11387 
  def __ne__(self, other):
11388 
    return not (self == other)
11389 
 
11390 
class getBannerMapDetails_result:
11391 
  """
11392 
  Attributes:
11393 
   - success
11394 
  """
11395 
 
11396 
  thrift_spec = (
11397 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11398 
  )
11399 
 
11400 
  def __init__(self, success=None,):
11401 
    self.success = success
11402 
 
11403 
  def read(self, iprot):
11404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11406 
      return
11407 
    iprot.readStructBegin()
11408 
    while True:
11409 
      (fname, ftype, fid) = iprot.readFieldBegin()
11410 
      if ftype == TType.STOP:
11411 
        break
11412 
      if fid == 0:
11413 
        if ftype == TType.LIST:
11414 
          self.success = []
6850 kshitij.so 11415 
          (_etype182, _size179) = iprot.readListBegin()
11416 
          for _i183 in xrange(_size179):
11417 
            _elem184 = BannerMap()
11418 
            _elem184.read(iprot)
11419 
            self.success.append(_elem184)
6849 kshitij.so 11420 
          iprot.readListEnd()
11421 
        else:
11422 
          iprot.skip(ftype)
11423 
      else:
11424 
        iprot.skip(ftype)
11425 
      iprot.readFieldEnd()
11426 
    iprot.readStructEnd()
11427 
 
11428 
  def write(self, oprot):
11429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11431 
      return
11432 
    oprot.writeStructBegin('getBannerMapDetails_result')
11433 
    if self.success is not None:
11434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11436 
      for iter185 in self.success:
11437 
        iter185.write(oprot)
6849 kshitij.so 11438 
      oprot.writeListEnd()
11439 
      oprot.writeFieldEnd()
11440 
    oprot.writeFieldStop()
11441 
    oprot.writeStructEnd()
11442 
 
11443 
  def validate(self):
11444 
    return
11445 
 
11446 
 
11447 
  def __repr__(self):
11448 
    L = ['%s=%r' % (key, value)
11449 
      for key, value in self.__dict__.iteritems()]
11450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11451 
 
11452 
  def __eq__(self, other):
11453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11454 
 
11455 
  def __ne__(self, other):
11456 
    return not (self == other)
11457 
 
5944 mandeep.dh 11458 
class deleteSimilarItem_args:
11459 
  """
11460 
  Attributes:
11461 
   - itemId
11462 
   - catalogItemId
11463 
  """
11464 
 
11465 
  thrift_spec = (
11466 
    None, # 0
11467 
    (1, TType.I64, 'itemId', None, None, ), # 1
11468 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11469 
  )
11470 
 
11471 
  def __init__(self, itemId=None, catalogItemId=None,):
11472 
    self.itemId = itemId
11473 
    self.catalogItemId = catalogItemId
11474 
 
11475 
  def read(self, iprot):
11476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11478 
      return
11479 
    iprot.readStructBegin()
11480 
    while True:
11481 
      (fname, ftype, fid) = iprot.readFieldBegin()
11482 
      if ftype == TType.STOP:
11483 
        break
11484 
      if fid == 1:
11485 
        if ftype == TType.I64:
11486 
          self.itemId = iprot.readI64();
11487 
        else:
11488 
          iprot.skip(ftype)
11489 
      elif fid == 2:
11490 
        if ftype == TType.I64:
11491 
          self.catalogItemId = iprot.readI64();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      else:
11495 
        iprot.skip(ftype)
11496 
      iprot.readFieldEnd()
11497 
    iprot.readStructEnd()
11498 
 
11499 
  def write(self, oprot):
11500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11502 
      return
11503 
    oprot.writeStructBegin('deleteSimilarItem_args')
11504 
    if self.itemId is not None:
11505 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11506 
      oprot.writeI64(self.itemId)
11507 
      oprot.writeFieldEnd()
11508 
    if self.catalogItemId is not None:
11509 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11510 
      oprot.writeI64(self.catalogItemId)
11511 
      oprot.writeFieldEnd()
11512 
    oprot.writeFieldStop()
11513 
    oprot.writeStructEnd()
11514 
 
11515 
  def validate(self):
11516 
    return
11517 
 
11518 
 
11519 
  def __repr__(self):
11520 
    L = ['%s=%r' % (key, value)
11521 
      for key, value in self.__dict__.iteritems()]
11522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11523 
 
11524 
  def __eq__(self, other):
11525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11526 
 
11527 
  def __ne__(self, other):
11528 
    return not (self == other)
11529 
 
11530 
class deleteSimilarItem_result:
11531 
  """
11532 
  Attributes:
11533 
   - success
11534 
   - cex
11535 
  """
11536 
 
11537 
  thrift_spec = (
11538 
    (0, TType.BOOL, 'success', None, None, ), # 0
11539 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11540 
  )
11541 
 
11542 
  def __init__(self, success=None, cex=None,):
11543 
    self.success = success
11544 
    self.cex = cex
11545 
 
11546 
  def read(self, iprot):
11547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11549 
      return
11550 
    iprot.readStructBegin()
11551 
    while True:
11552 
      (fname, ftype, fid) = iprot.readFieldBegin()
11553 
      if ftype == TType.STOP:
11554 
        break
11555 
      if fid == 0:
11556 
        if ftype == TType.BOOL:
11557 
          self.success = iprot.readBool();
11558 
        else:
11559 
          iprot.skip(ftype)
11560 
      elif fid == 1:
11561 
        if ftype == TType.STRUCT:
11562 
          self.cex = CatalogServiceException()
11563 
          self.cex.read(iprot)
11564 
        else:
11565 
          iprot.skip(ftype)
11566 
      else:
11567 
        iprot.skip(ftype)
11568 
      iprot.readFieldEnd()
11569 
    iprot.readStructEnd()
11570 
 
11571 
  def write(self, oprot):
11572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11574 
      return
11575 
    oprot.writeStructBegin('deleteSimilarItem_result')
11576 
    if self.success is not None:
11577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11578 
      oprot.writeBool(self.success)
11579 
      oprot.writeFieldEnd()
11580 
    if self.cex is not None:
11581 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11582 
      self.cex.write(oprot)
11583 
      oprot.writeFieldEnd()
11584 
    oprot.writeFieldStop()
11585 
    oprot.writeStructEnd()
11586 
 
11587 
  def validate(self):
11588 
    return
11589 
 
11590 
 
11591 
  def __repr__(self):
11592 
    L = ['%s=%r' % (key, value)
11593 
      for key, value in self.__dict__.iteritems()]
11594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11595 
 
11596 
  def __eq__(self, other):
11597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11598 
 
11599 
  def __ne__(self, other):
11600 
    return not (self == other)
11601 
 
11602 
class checkSimilarItem_args:
11603 
  """
11604 
  Attributes:
11605 
   - brand
11606 
   - modelNumber
11607 
   - modelName
11608 
   - color
11609 
  """
11610 
 
11611 
  thrift_spec = (
11612 
    None, # 0
11613 
    (1, TType.STRING, 'brand', None, None, ), # 1
11614 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11615 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11616 
    (4, TType.STRING, 'color', None, None, ), # 4
11617 
  )
11618 
 
11619 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11620 
    self.brand = brand
11621 
    self.modelNumber = modelNumber
11622 
    self.modelName = modelName
11623 
    self.color = color
11624 
 
11625 
  def read(self, iprot):
11626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11628 
      return
11629 
    iprot.readStructBegin()
11630 
    while True:
11631 
      (fname, ftype, fid) = iprot.readFieldBegin()
11632 
      if ftype == TType.STOP:
11633 
        break
11634 
      if fid == 1:
11635 
        if ftype == TType.STRING:
11636 
          self.brand = iprot.readString();
11637 
        else:
11638 
          iprot.skip(ftype)
11639 
      elif fid == 2:
11640 
        if ftype == TType.STRING:
11641 
          self.modelNumber = iprot.readString();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      elif fid == 3:
11645 
        if ftype == TType.STRING:
11646 
          self.modelName = iprot.readString();
11647 
        else:
11648 
          iprot.skip(ftype)
11649 
      elif fid == 4:
11650 
        if ftype == TType.STRING:
11651 
          self.color = iprot.readString();
11652 
        else:
11653 
          iprot.skip(ftype)
11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
11663 
    oprot.writeStructBegin('checkSimilarItem_args')
11664 
    if self.brand is not None:
11665 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11666 
      oprot.writeString(self.brand)
11667 
      oprot.writeFieldEnd()
11668 
    if self.modelNumber is not None:
11669 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11670 
      oprot.writeString(self.modelNumber)
11671 
      oprot.writeFieldEnd()
11672 
    if self.modelName is not None:
11673 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11674 
      oprot.writeString(self.modelName)
11675 
      oprot.writeFieldEnd()
11676 
    if self.color is not None:
11677 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11678 
      oprot.writeString(self.color)
11679 
      oprot.writeFieldEnd()
11680 
    oprot.writeFieldStop()
11681 
    oprot.writeStructEnd()
11682 
 
11683 
  def validate(self):
11684 
    return
11685 
 
11686 
 
11687 
  def __repr__(self):
11688 
    L = ['%s=%r' % (key, value)
11689 
      for key, value in self.__dict__.iteritems()]
11690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11691 
 
11692 
  def __eq__(self, other):
11693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11694 
 
11695 
  def __ne__(self, other):
11696 
    return not (self == other)
11697 
 
11698 
class checkSimilarItem_result:
11699 
  """
11700 
  Attributes:
11701 
   - success
11702 
  """
11703 
 
11704 
  thrift_spec = (
11705 
    (0, TType.I64, 'success', None, None, ), # 0
11706 
  )
11707 
 
11708 
  def __init__(self, success=None,):
11709 
    self.success = success
11710 
 
11711 
  def read(self, iprot):
11712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11714 
      return
11715 
    iprot.readStructBegin()
11716 
    while True:
11717 
      (fname, ftype, fid) = iprot.readFieldBegin()
11718 
      if ftype == TType.STOP:
11719 
        break
11720 
      if fid == 0:
11721 
        if ftype == TType.I64:
11722 
          self.success = iprot.readI64();
11723 
        else:
11724 
          iprot.skip(ftype)
11725 
      else:
11726 
        iprot.skip(ftype)
11727 
      iprot.readFieldEnd()
11728 
    iprot.readStructEnd()
11729 
 
11730 
  def write(self, oprot):
11731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11733 
      return
11734 
    oprot.writeStructBegin('checkSimilarItem_result')
11735 
    if self.success is not None:
11736 
      oprot.writeFieldBegin('success', TType.I64, 0)
11737 
      oprot.writeI64(self.success)
11738 
      oprot.writeFieldEnd()
11739 
    oprot.writeFieldStop()
11740 
    oprot.writeStructEnd()
11741 
 
11742 
  def validate(self):
11743 
    return
11744 
 
11745 
 
11746 
  def __repr__(self):
11747 
    L = ['%s=%r' % (key, value)
11748 
      for key, value in self.__dict__.iteritems()]
11749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11750 
 
11751 
  def __eq__(self, other):
11752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11753 
 
11754 
  def __ne__(self, other):
11755 
    return not (self == other)
11756 
 
11757 
class validateRiskyStatus_args:
11758 
  """
11759 
  Attributes:
11760 
   - itemId
11761 
  """
11762 
 
11763 
  thrift_spec = (
11764 
    None, # 0
11765 
    (1, TType.I64, 'itemId', None, None, ), # 1
11766 
  )
11767 
 
11768 
  def __init__(self, itemId=None,):
11769 
    self.itemId = itemId
11770 
 
11771 
  def read(self, iprot):
11772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11774 
      return
11775 
    iprot.readStructBegin()
11776 
    while True:
11777 
      (fname, ftype, fid) = iprot.readFieldBegin()
11778 
      if ftype == TType.STOP:
11779 
        break
11780 
      if fid == 1:
11781 
        if ftype == TType.I64:
11782 
          self.itemId = iprot.readI64();
11783 
        else:
11784 
          iprot.skip(ftype)
11785 
      else:
11786 
        iprot.skip(ftype)
11787 
      iprot.readFieldEnd()
11788 
    iprot.readStructEnd()
11789 
 
11790 
  def write(self, oprot):
11791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11793 
      return
11794 
    oprot.writeStructBegin('validateRiskyStatus_args')
11795 
    if self.itemId is not None:
11796 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11797 
      oprot.writeI64(self.itemId)
11798 
      oprot.writeFieldEnd()
11799 
    oprot.writeFieldStop()
11800 
    oprot.writeStructEnd()
11801 
 
11802 
  def validate(self):
11803 
    return
11804 
 
11805 
 
11806 
  def __repr__(self):
11807 
    L = ['%s=%r' % (key, value)
11808 
      for key, value in self.__dict__.iteritems()]
11809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11810 
 
11811 
  def __eq__(self, other):
11812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11813 
 
11814 
  def __ne__(self, other):
11815 
    return not (self == other)
11816 
 
11817 
class validateRiskyStatus_result:
11818 
 
11819 
  thrift_spec = (
11820 
  )
11821 
 
11822 
  def read(self, iprot):
11823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11825 
      return
11826 
    iprot.readStructBegin()
11827 
    while True:
11828 
      (fname, ftype, fid) = iprot.readFieldBegin()
11829 
      if ftype == TType.STOP:
11830 
        break
11831 
      else:
11832 
        iprot.skip(ftype)
11833 
      iprot.readFieldEnd()
11834 
    iprot.readStructEnd()
11835 
 
11836 
  def write(self, oprot):
11837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11839 
      return
11840 
    oprot.writeStructBegin('validateRiskyStatus_result')
11841 
    oprot.writeFieldStop()
11842 
    oprot.writeStructEnd()
11843 
 
11844 
  def validate(self):
11845 
    return
11846 
 
11847 
 
11848 
  def __repr__(self):
11849 
    L = ['%s=%r' % (key, value)
11850 
      for key, value in self.__dict__.iteritems()]
11851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11852 
 
11853 
  def __eq__(self, other):
11854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11855 
 
11856 
  def __ne__(self, other):
11857 
    return not (self == other)
11858 
 
11859 
class changeItemRiskyFlag_args:
11860 
  """
11861 
  Attributes:
11862 
   - itemId
11863 
   - risky
11864 
  """
11865 
 
11866 
  thrift_spec = (
11867 
    None, # 0
11868 
    (1, TType.I64, 'itemId', None, None, ), # 1
11869 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11870 
  )
11871 
 
11872 
  def __init__(self, itemId=None, risky=None,):
11873 
    self.itemId = itemId
11874 
    self.risky = risky
11875 
 
11876 
  def read(self, iprot):
11877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11879 
      return
11880 
    iprot.readStructBegin()
11881 
    while True:
11882 
      (fname, ftype, fid) = iprot.readFieldBegin()
11883 
      if ftype == TType.STOP:
11884 
        break
11885 
      if fid == 1:
11886 
        if ftype == TType.I64:
11887 
          self.itemId = iprot.readI64();
11888 
        else:
11889 
          iprot.skip(ftype)
11890 
      elif fid == 2:
11891 
        if ftype == TType.BOOL:
11892 
          self.risky = iprot.readBool();
11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      else:
11896 
        iprot.skip(ftype)
11897 
      iprot.readFieldEnd()
11898 
    iprot.readStructEnd()
11899 
 
11900 
  def write(self, oprot):
11901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11903 
      return
11904 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11905 
    if self.itemId is not None:
11906 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11907 
      oprot.writeI64(self.itemId)
11908 
      oprot.writeFieldEnd()
11909 
    if self.risky is not None:
11910 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11911 
      oprot.writeBool(self.risky)
11912 
      oprot.writeFieldEnd()
11913 
    oprot.writeFieldStop()
11914 
    oprot.writeStructEnd()
11915 
 
11916 
  def validate(self):
11917 
    return
11918 
 
11919 
 
11920 
  def __repr__(self):
11921 
    L = ['%s=%r' % (key, value)
11922 
      for key, value in self.__dict__.iteritems()]
11923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11924 
 
11925 
  def __eq__(self, other):
11926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11927 
 
11928 
  def __ne__(self, other):
11929 
    return not (self == other)
11930 
 
11931 
class changeItemRiskyFlag_result:
11932 
 
11933 
  thrift_spec = (
11934 
  )
11935 
 
11936 
  def read(self, iprot):
11937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11939 
      return
11940 
    iprot.readStructBegin()
11941 
    while True:
11942 
      (fname, ftype, fid) = iprot.readFieldBegin()
11943 
      if ftype == TType.STOP:
11944 
        break
11945 
      else:
11946 
        iprot.skip(ftype)
11947 
      iprot.readFieldEnd()
11948 
    iprot.readStructEnd()
11949 
 
11950 
  def write(self, oprot):
11951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11953 
      return
11954 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11955 
    oprot.writeFieldStop()
11956 
    oprot.writeStructEnd()
11957 
 
11958 
  def validate(self):
11959 
    return
11960 
 
11961 
 
11962 
  def __repr__(self):
11963 
    L = ['%s=%r' % (key, value)
11964 
      for key, value in self.__dict__.iteritems()]
11965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11966 
 
11967 
  def __eq__(self, other):
11968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11969 
 
11970 
  def __ne__(self, other):
11971 
    return not (self == other)
11972 
 
11973 
class getItemsByRiskyFlag_args:
11974 
 
11975 
  thrift_spec = (
11976 
  )
11977 
 
11978 
  def read(self, iprot):
11979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11981 
      return
11982 
    iprot.readStructBegin()
11983 
    while True:
11984 
      (fname, ftype, fid) = iprot.readFieldBegin()
11985 
      if ftype == TType.STOP:
11986 
        break
11987 
      else:
11988 
        iprot.skip(ftype)
11989 
      iprot.readFieldEnd()
11990 
    iprot.readStructEnd()
11991 
 
11992 
  def write(self, oprot):
11993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11995 
      return
11996 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
11997 
    oprot.writeFieldStop()
11998 
    oprot.writeStructEnd()
11999 
 
12000 
  def validate(self):
12001 
    return
12002 
 
12003 
 
12004 
  def __repr__(self):
12005 
    L = ['%s=%r' % (key, value)
12006 
      for key, value in self.__dict__.iteritems()]
12007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12008 
 
12009 
  def __eq__(self, other):
12010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12011 
 
12012 
  def __ne__(self, other):
12013 
    return not (self == other)
12014 
 
12015 
class getItemsByRiskyFlag_result:
12016 
  """
12017 
  Attributes:
12018 
   - success
12019 
  """
12020 
 
12021 
  thrift_spec = (
12022 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12023 
  )
12024 
 
12025 
  def __init__(self, success=None,):
12026 
    self.success = success
12027 
 
12028 
  def read(self, iprot):
12029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12031 
      return
12032 
    iprot.readStructBegin()
12033 
    while True:
12034 
      (fname, ftype, fid) = iprot.readFieldBegin()
12035 
      if ftype == TType.STOP:
12036 
        break
12037 
      if fid == 0:
12038 
        if ftype == TType.LIST:
12039 
          self.success = []
6850 kshitij.so 12040 
          (_etype189, _size186) = iprot.readListBegin()
12041 
          for _i190 in xrange(_size186):
12042 
            _elem191 = Item()
12043 
            _elem191.read(iprot)
12044 
            self.success.append(_elem191)
5944 mandeep.dh 12045 
          iprot.readListEnd()
12046 
        else:
12047 
          iprot.skip(ftype)
12048 
      else:
12049 
        iprot.skip(ftype)
12050 
      iprot.readFieldEnd()
12051 
    iprot.readStructEnd()
12052 
 
12053 
  def write(self, oprot):
12054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12056 
      return
12057 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12058 
    if self.success is not None:
12059 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12060 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12061 
      for iter192 in self.success:
12062 
        iter192.write(oprot)
5944 mandeep.dh 12063 
      oprot.writeListEnd()
12064 
      oprot.writeFieldEnd()
12065 
    oprot.writeFieldStop()
12066 
    oprot.writeStructEnd()
12067 
 
12068 
  def validate(self):
12069 
    return
12070 
 
12071 
 
12072 
  def __repr__(self):
12073 
    L = ['%s=%r' % (key, value)
12074 
      for key, value in self.__dict__.iteritems()]
12075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12076 
 
12077 
  def __eq__(self, other):
12078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12079 
 
12080 
  def __ne__(self, other):
12081 
    return not (self == other)
12082 
 
12083 
class getItemsForMasterSheet_args:
12084 
  """
12085 
  Attributes:
12086 
   - category
12087 
   - brand
12088 
  """
12089 
 
12090 
  thrift_spec = (
12091 
    None, # 0
12092 
    (1, TType.STRING, 'category', None, None, ), # 1
12093 
    (2, TType.STRING, 'brand', None, None, ), # 2
12094 
  )
12095 
 
12096 
  def __init__(self, category=None, brand=None,):
12097 
    self.category = category
12098 
    self.brand = brand
12099 
 
12100 
  def read(self, iprot):
12101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12103 
      return
12104 
    iprot.readStructBegin()
12105 
    while True:
12106 
      (fname, ftype, fid) = iprot.readFieldBegin()
12107 
      if ftype == TType.STOP:
12108 
        break
12109 
      if fid == 1:
12110 
        if ftype == TType.STRING:
12111 
          self.category = iprot.readString();
12112 
        else:
12113 
          iprot.skip(ftype)
12114 
      elif fid == 2:
12115 
        if ftype == TType.STRING:
12116 
          self.brand = iprot.readString();
12117 
        else:
12118 
          iprot.skip(ftype)
12119 
      else:
12120 
        iprot.skip(ftype)
12121 
      iprot.readFieldEnd()
12122 
    iprot.readStructEnd()
12123 
 
12124 
  def write(self, oprot):
12125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12127 
      return
12128 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12129 
    if self.category is not None:
12130 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12131 
      oprot.writeString(self.category)
12132 
      oprot.writeFieldEnd()
12133 
    if self.brand is not None:
12134 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12135 
      oprot.writeString(self.brand)
12136 
      oprot.writeFieldEnd()
12137 
    oprot.writeFieldStop()
12138 
    oprot.writeStructEnd()
12139 
 
12140 
  def validate(self):
12141 
    return
12142 
 
12143 
 
12144 
  def __repr__(self):
12145 
    L = ['%s=%r' % (key, value)
12146 
      for key, value in self.__dict__.iteritems()]
12147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12148 
 
12149 
  def __eq__(self, other):
12150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12151 
 
12152 
  def __ne__(self, other):
12153 
    return not (self == other)
12154 
 
12155 
class getItemsForMasterSheet_result:
12156 
  """
12157 
  Attributes:
12158 
   - success
12159 
  """
12160 
 
12161 
  thrift_spec = (
12162 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12163 
  )
12164 
 
12165 
  def __init__(self, success=None,):
12166 
    self.success = success
12167 
 
12168 
  def read(self, iprot):
12169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12171 
      return
12172 
    iprot.readStructBegin()
12173 
    while True:
12174 
      (fname, ftype, fid) = iprot.readFieldBegin()
12175 
      if ftype == TType.STOP:
12176 
        break
12177 
      if fid == 0:
12178 
        if ftype == TType.LIST:
12179 
          self.success = []
6850 kshitij.so 12180 
          (_etype196, _size193) = iprot.readListBegin()
12181 
          for _i197 in xrange(_size193):
12182 
            _elem198 = Item()
12183 
            _elem198.read(iprot)
12184 
            self.success.append(_elem198)
5944 mandeep.dh 12185 
          iprot.readListEnd()
12186 
        else:
12187 
          iprot.skip(ftype)
12188 
      else:
12189 
        iprot.skip(ftype)
12190 
      iprot.readFieldEnd()
12191 
    iprot.readStructEnd()
12192 
 
12193 
  def write(self, oprot):
12194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12196 
      return
12197 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12198 
    if self.success is not None:
12199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12201 
      for iter199 in self.success:
12202 
        iter199.write(oprot)
5944 mandeep.dh 12203 
      oprot.writeListEnd()
12204 
      oprot.writeFieldEnd()
12205 
    oprot.writeFieldStop()
12206 
    oprot.writeStructEnd()
12207 
 
12208 
  def validate(self):
12209 
    return
12210 
 
12211 
 
12212 
  def __repr__(self):
12213 
    L = ['%s=%r' % (key, value)
12214 
      for key, value in self.__dict__.iteritems()]
12215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12216 
 
12217 
  def __eq__(self, other):
12218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12219 
 
12220 
  def __ne__(self, other):
12221 
    return not (self == other)
12222 
 
12223 
class getSimilarItemsCatalogIds_args:
12224 
  """
12225 
  Attributes:
12226 
   - beginIndex
12227 
   - totalItems
12228 
   - itemId
12229 
  """
12230 
 
12231 
  thrift_spec = (
12232 
    None, # 0
12233 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12234 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12235 
    (3, TType.I64, 'itemId', None, None, ), # 3
12236 
  )
12237 
 
12238 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12239 
    self.beginIndex = beginIndex
12240 
    self.totalItems = totalItems
12241 
    self.itemId = itemId
12242 
 
12243 
  def read(self, iprot):
12244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12246 
      return
12247 
    iprot.readStructBegin()
12248 
    while True:
12249 
      (fname, ftype, fid) = iprot.readFieldBegin()
12250 
      if ftype == TType.STOP:
12251 
        break
12252 
      if fid == 1:
12253 
        if ftype == TType.I64:
12254 
          self.beginIndex = iprot.readI64();
12255 
        else:
12256 
          iprot.skip(ftype)
12257 
      elif fid == 2:
12258 
        if ftype == TType.I64:
12259 
          self.totalItems = iprot.readI64();
12260 
        else:
12261 
          iprot.skip(ftype)
12262 
      elif fid == 3:
12263 
        if ftype == TType.I64:
12264 
          self.itemId = iprot.readI64();
12265 
        else:
12266 
          iprot.skip(ftype)
12267 
      else:
12268 
        iprot.skip(ftype)
12269 
      iprot.readFieldEnd()
12270 
    iprot.readStructEnd()
12271 
 
12272 
  def write(self, oprot):
12273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12275 
      return
12276 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12277 
    if self.beginIndex is not None:
12278 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12279 
      oprot.writeI64(self.beginIndex)
12280 
      oprot.writeFieldEnd()
12281 
    if self.totalItems is not None:
12282 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12283 
      oprot.writeI64(self.totalItems)
12284 
      oprot.writeFieldEnd()
12285 
    if self.itemId is not None:
12286 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12287 
      oprot.writeI64(self.itemId)
12288 
      oprot.writeFieldEnd()
12289 
    oprot.writeFieldStop()
12290 
    oprot.writeStructEnd()
12291 
 
12292 
  def validate(self):
12293 
    return
12294 
 
12295 
 
12296 
  def __repr__(self):
12297 
    L = ['%s=%r' % (key, value)
12298 
      for key, value in self.__dict__.iteritems()]
12299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12300 
 
12301 
  def __eq__(self, other):
12302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12303 
 
12304 
  def __ne__(self, other):
12305 
    return not (self == other)
12306 
 
12307 
class getSimilarItemsCatalogIds_result:
12308 
  """
12309 
  Attributes:
12310 
   - success
12311 
  """
12312 
 
12313 
  thrift_spec = (
12314 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12315 
  )
12316 
 
12317 
  def __init__(self, success=None,):
12318 
    self.success = success
12319 
 
12320 
  def read(self, iprot):
12321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12323 
      return
12324 
    iprot.readStructBegin()
12325 
    while True:
12326 
      (fname, ftype, fid) = iprot.readFieldBegin()
12327 
      if ftype == TType.STOP:
12328 
        break
12329 
      if fid == 0:
12330 
        if ftype == TType.LIST:
12331 
          self.success = []
6850 kshitij.so 12332 
          (_etype203, _size200) = iprot.readListBegin()
12333 
          for _i204 in xrange(_size200):
12334 
            _elem205 = iprot.readI64();
12335 
            self.success.append(_elem205)
5944 mandeep.dh 12336 
          iprot.readListEnd()
12337 
        else:
12338 
          iprot.skip(ftype)
12339 
      else:
12340 
        iprot.skip(ftype)
12341 
      iprot.readFieldEnd()
12342 
    iprot.readStructEnd()
12343 
 
12344 
  def write(self, oprot):
12345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12347 
      return
12348 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12349 
    if self.success is not None:
12350 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12351 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12352 
      for iter206 in self.success:
12353 
        oprot.writeI64(iter206)
5944 mandeep.dh 12354 
      oprot.writeListEnd()
12355 
      oprot.writeFieldEnd()
12356 
    oprot.writeFieldStop()
12357 
    oprot.writeStructEnd()
12358 
 
12359 
  def validate(self):
12360 
    return
12361 
 
12362 
 
12363 
  def __repr__(self):
12364 
    L = ['%s=%r' % (key, value)
12365 
      for key, value in self.__dict__.iteritems()]
12366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12367 
 
12368 
  def __eq__(self, other):
12369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12370 
 
12371 
  def __ne__(self, other):
12372 
    return not (self == other)
12373 
 
12374 
class addProductNotification_args:
12375 
  """
12376 
  Attributes:
12377 
   - itemId
12378 
   - email
12379 
  """
12380 
 
12381 
  thrift_spec = None
12382 
  def __init__(self, itemId=None, email=None,):
12383 
    self.itemId = itemId
12384 
    self.email = email
12385 
 
12386 
  def read(self, iprot):
12387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12389 
      return
12390 
    iprot.readStructBegin()
12391 
    while True:
12392 
      (fname, ftype, fid) = iprot.readFieldBegin()
12393 
      if ftype == TType.STOP:
12394 
        break
12395 
      if fid == -1:
12396 
        if ftype == TType.I64:
12397 
          self.itemId = iprot.readI64();
12398 
        else:
12399 
          iprot.skip(ftype)
12400 
      elif fid == -2:
12401 
        if ftype == TType.STRING:
12402 
          self.email = iprot.readString();
12403 
        else:
12404 
          iprot.skip(ftype)
12405 
      else:
12406 
        iprot.skip(ftype)
12407 
      iprot.readFieldEnd()
12408 
    iprot.readStructEnd()
12409 
 
12410 
  def write(self, oprot):
12411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12413 
      return
12414 
    oprot.writeStructBegin('addProductNotification_args')
12415 
    if self.email is not None:
12416 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12417 
      oprot.writeString(self.email)
12418 
      oprot.writeFieldEnd()
12419 
    if self.itemId is not None:
12420 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12421 
      oprot.writeI64(self.itemId)
12422 
      oprot.writeFieldEnd()
12423 
    oprot.writeFieldStop()
12424 
    oprot.writeStructEnd()
12425 
 
12426 
  def validate(self):
12427 
    return
12428 
 
12429 
 
12430 
  def __repr__(self):
12431 
    L = ['%s=%r' % (key, value)
12432 
      for key, value in self.__dict__.iteritems()]
12433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12434 
 
12435 
  def __eq__(self, other):
12436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12437 
 
12438 
  def __ne__(self, other):
12439 
    return not (self == other)
12440 
 
12441 
class addProductNotification_result:
12442 
  """
12443 
  Attributes:
12444 
   - success
12445 
  """
12446 
 
12447 
  thrift_spec = (
12448 
    (0, TType.BOOL, 'success', None, None, ), # 0
12449 
  )
12450 
 
12451 
  def __init__(self, success=None,):
12452 
    self.success = success
12453 
 
12454 
  def read(self, iprot):
12455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12457 
      return
12458 
    iprot.readStructBegin()
12459 
    while True:
12460 
      (fname, ftype, fid) = iprot.readFieldBegin()
12461 
      if ftype == TType.STOP:
12462 
        break
12463 
      if fid == 0:
12464 
        if ftype == TType.BOOL:
12465 
          self.success = iprot.readBool();
12466 
        else:
12467 
          iprot.skip(ftype)
12468 
      else:
12469 
        iprot.skip(ftype)
12470 
      iprot.readFieldEnd()
12471 
    iprot.readStructEnd()
12472 
 
12473 
  def write(self, oprot):
12474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12476 
      return
12477 
    oprot.writeStructBegin('addProductNotification_result')
12478 
    if self.success is not None:
12479 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12480 
      oprot.writeBool(self.success)
12481 
      oprot.writeFieldEnd()
12482 
    oprot.writeFieldStop()
12483 
    oprot.writeStructEnd()
12484 
 
12485 
  def validate(self):
12486 
    return
12487 
 
12488 
 
12489 
  def __repr__(self):
12490 
    L = ['%s=%r' % (key, value)
12491 
      for key, value in self.__dict__.iteritems()]
12492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12493 
 
12494 
  def __eq__(self, other):
12495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12496 
 
12497 
  def __ne__(self, other):
12498 
    return not (self == other)
12499 
 
12500 
class sendProductNotifications_args:
12501 
 
12502 
  thrift_spec = (
12503 
  )
12504 
 
12505 
  def read(self, iprot):
12506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12508 
      return
12509 
    iprot.readStructBegin()
12510 
    while True:
12511 
      (fname, ftype, fid) = iprot.readFieldBegin()
12512 
      if ftype == TType.STOP:
12513 
        break
12514 
      else:
12515 
        iprot.skip(ftype)
12516 
      iprot.readFieldEnd()
12517 
    iprot.readStructEnd()
12518 
 
12519 
  def write(self, oprot):
12520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12522 
      return
12523 
    oprot.writeStructBegin('sendProductNotifications_args')
12524 
    oprot.writeFieldStop()
12525 
    oprot.writeStructEnd()
12526 
 
12527 
  def validate(self):
12528 
    return
12529 
 
12530 
 
12531 
  def __repr__(self):
12532 
    L = ['%s=%r' % (key, value)
12533 
      for key, value in self.__dict__.iteritems()]
12534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12535 
 
12536 
  def __eq__(self, other):
12537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12538 
 
12539 
  def __ne__(self, other):
12540 
    return not (self == other)
12541 
 
12542 
class sendProductNotifications_result:
12543 
  """
12544 
  Attributes:
12545 
   - success
12546 
  """
12547 
 
12548 
  thrift_spec = (
12549 
    (0, TType.BOOL, 'success', None, None, ), # 0
12550 
  )
12551 
 
12552 
  def __init__(self, success=None,):
12553 
    self.success = success
12554 
 
12555 
  def read(self, iprot):
12556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12558 
      return
12559 
    iprot.readStructBegin()
12560 
    while True:
12561 
      (fname, ftype, fid) = iprot.readFieldBegin()
12562 
      if ftype == TType.STOP:
12563 
        break
12564 
      if fid == 0:
12565 
        if ftype == TType.BOOL:
12566 
          self.success = iprot.readBool();
12567 
        else:
12568 
          iprot.skip(ftype)
12569 
      else:
12570 
        iprot.skip(ftype)
12571 
      iprot.readFieldEnd()
12572 
    iprot.readStructEnd()
12573 
 
12574 
  def write(self, oprot):
12575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12577 
      return
12578 
    oprot.writeStructBegin('sendProductNotifications_result')
12579 
    if self.success is not None:
12580 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12581 
      oprot.writeBool(self.success)
12582 
      oprot.writeFieldEnd()
12583 
    oprot.writeFieldStop()
12584 
    oprot.writeStructEnd()
12585 
 
12586 
  def validate(self):
12587 
    return
12588 
 
12589 
 
12590 
  def __repr__(self):
12591 
    L = ['%s=%r' % (key, value)
12592 
      for key, value in self.__dict__.iteritems()]
12593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12594 
 
12595 
  def __eq__(self, other):
12596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12597 
 
12598 
  def __ne__(self, other):
12599 
    return not (self == other)
12600 
 
12601 
class getAllBrandsByCategory_args:
12602 
  """
12603 
  Attributes:
12604 
   - categoryId
12605 
  """
12606 
 
12607 
  thrift_spec = (
12608 
    None, # 0
12609 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12610 
  )
12611 
 
12612 
  def __init__(self, categoryId=None,):
12613 
    self.categoryId = categoryId
12614 
 
12615 
  def read(self, iprot):
12616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12618 
      return
12619 
    iprot.readStructBegin()
12620 
    while True:
12621 
      (fname, ftype, fid) = iprot.readFieldBegin()
12622 
      if ftype == TType.STOP:
12623 
        break
12624 
      if fid == 1:
12625 
        if ftype == TType.I64:
12626 
          self.categoryId = iprot.readI64();
12627 
        else:
12628 
          iprot.skip(ftype)
12629 
      else:
12630 
        iprot.skip(ftype)
12631 
      iprot.readFieldEnd()
12632 
    iprot.readStructEnd()
12633 
 
12634 
  def write(self, oprot):
12635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12637 
      return
12638 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12639 
    if self.categoryId is not None:
12640 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12641 
      oprot.writeI64(self.categoryId)
12642 
      oprot.writeFieldEnd()
12643 
    oprot.writeFieldStop()
12644 
    oprot.writeStructEnd()
12645 
 
12646 
  def validate(self):
12647 
    return
12648 
 
12649 
 
12650 
  def __repr__(self):
12651 
    L = ['%s=%r' % (key, value)
12652 
      for key, value in self.__dict__.iteritems()]
12653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12654 
 
12655 
  def __eq__(self, other):
12656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12657 
 
12658 
  def __ne__(self, other):
12659 
    return not (self == other)
12660 
 
12661 
class getAllBrandsByCategory_result:
12662 
  """
12663 
  Attributes:
12664 
   - success
12665 
  """
12666 
 
12667 
  thrift_spec = (
12668 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12669 
  )
12670 
 
12671 
  def __init__(self, success=None,):
12672 
    self.success = success
12673 
 
12674 
  def read(self, iprot):
12675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12677 
      return
12678 
    iprot.readStructBegin()
12679 
    while True:
12680 
      (fname, ftype, fid) = iprot.readFieldBegin()
12681 
      if ftype == TType.STOP:
12682 
        break
12683 
      if fid == 0:
12684 
        if ftype == TType.LIST:
12685 
          self.success = []
6850 kshitij.so 12686 
          (_etype210, _size207) = iprot.readListBegin()
12687 
          for _i211 in xrange(_size207):
12688 
            _elem212 = iprot.readString();
12689 
            self.success.append(_elem212)
5944 mandeep.dh 12690 
          iprot.readListEnd()
12691 
        else:
12692 
          iprot.skip(ftype)
12693 
      else:
12694 
        iprot.skip(ftype)
12695 
      iprot.readFieldEnd()
12696 
    iprot.readStructEnd()
12697 
 
12698 
  def write(self, oprot):
12699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12701 
      return
12702 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12703 
    if self.success is not None:
12704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12705 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12706 
      for iter213 in self.success:
12707 
        oprot.writeString(iter213)
5944 mandeep.dh 12708 
      oprot.writeListEnd()
12709 
      oprot.writeFieldEnd()
12710 
    oprot.writeFieldStop()
12711 
    oprot.writeStructEnd()
12712 
 
12713 
  def validate(self):
12714 
    return
12715 
 
12716 
 
12717 
  def __repr__(self):
12718 
    L = ['%s=%r' % (key, value)
12719 
      for key, value in self.__dict__.iteritems()]
12720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12721 
 
12722 
  def __eq__(self, other):
12723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12724 
 
12725 
  def __ne__(self, other):
12726 
    return not (self == other)
12727 
 
12728 
class getAllBrands_args:
12729 
 
12730 
  thrift_spec = (
12731 
  )
12732 
 
12733 
  def read(self, iprot):
12734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12736 
      return
12737 
    iprot.readStructBegin()
12738 
    while True:
12739 
      (fname, ftype, fid) = iprot.readFieldBegin()
12740 
      if ftype == TType.STOP:
12741 
        break
12742 
      else:
12743 
        iprot.skip(ftype)
12744 
      iprot.readFieldEnd()
12745 
    iprot.readStructEnd()
12746 
 
12747 
  def write(self, oprot):
12748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12750 
      return
12751 
    oprot.writeStructBegin('getAllBrands_args')
12752 
    oprot.writeFieldStop()
12753 
    oprot.writeStructEnd()
12754 
 
12755 
  def validate(self):
12756 
    return
12757 
 
12758 
 
12759 
  def __repr__(self):
12760 
    L = ['%s=%r' % (key, value)
12761 
      for key, value in self.__dict__.iteritems()]
12762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12763 
 
12764 
  def __eq__(self, other):
12765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12766 
 
12767 
  def __ne__(self, other):
12768 
    return not (self == other)
12769 
 
12770 
class getAllBrands_result:
12771 
  """
12772 
  Attributes:
12773 
   - success
12774 
  """
12775 
 
12776 
  thrift_spec = (
12777 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12778 
  )
12779 
 
12780 
  def __init__(self, success=None,):
12781 
    self.success = success
12782 
 
12783 
  def read(self, iprot):
12784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12786 
      return
12787 
    iprot.readStructBegin()
12788 
    while True:
12789 
      (fname, ftype, fid) = iprot.readFieldBegin()
12790 
      if ftype == TType.STOP:
12791 
        break
12792 
      if fid == 0:
12793 
        if ftype == TType.LIST:
12794 
          self.success = []
6850 kshitij.so 12795 
          (_etype217, _size214) = iprot.readListBegin()
12796 
          for _i218 in xrange(_size214):
12797 
            _elem219 = iprot.readString();
12798 
            self.success.append(_elem219)
5944 mandeep.dh 12799 
          iprot.readListEnd()
12800 
        else:
12801 
          iprot.skip(ftype)
12802 
      else:
12803 
        iprot.skip(ftype)
12804 
      iprot.readFieldEnd()
12805 
    iprot.readStructEnd()
12806 
 
12807 
  def write(self, oprot):
12808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12810 
      return
12811 
    oprot.writeStructBegin('getAllBrands_result')
12812 
    if self.success is not None:
12813 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12814 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12815 
      for iter220 in self.success:
12816 
        oprot.writeString(iter220)
5944 mandeep.dh 12817 
      oprot.writeListEnd()
12818 
      oprot.writeFieldEnd()
12819 
    oprot.writeFieldStop()
12820 
    oprot.writeStructEnd()
12821 
 
12822 
  def validate(self):
12823 
    return
12824 
 
12825 
 
12826 
  def __repr__(self):
12827 
    L = ['%s=%r' % (key, value)
12828 
      for key, value in self.__dict__.iteritems()]
12829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12830 
 
12831 
  def __eq__(self, other):
12832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12833 
 
12834 
  def __ne__(self, other):
12835 
    return not (self == other)
12836 
 
12837 
class getAllSources_args:
12838 
 
12839 
  thrift_spec = (
12840 
  )
12841 
 
12842 
  def read(self, iprot):
12843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12845 
      return
12846 
    iprot.readStructBegin()
12847 
    while True:
12848 
      (fname, ftype, fid) = iprot.readFieldBegin()
12849 
      if ftype == TType.STOP:
12850 
        break
12851 
      else:
12852 
        iprot.skip(ftype)
12853 
      iprot.readFieldEnd()
12854 
    iprot.readStructEnd()
12855 
 
12856 
  def write(self, oprot):
12857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12859 
      return
12860 
    oprot.writeStructBegin('getAllSources_args')
12861 
    oprot.writeFieldStop()
12862 
    oprot.writeStructEnd()
12863 
 
12864 
  def validate(self):
12865 
    return
12866 
 
12867 
 
12868 
  def __repr__(self):
12869 
    L = ['%s=%r' % (key, value)
12870 
      for key, value in self.__dict__.iteritems()]
12871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12872 
 
12873 
  def __eq__(self, other):
12874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12875 
 
12876 
  def __ne__(self, other):
12877 
    return not (self == other)
12878 
 
12879 
class getAllSources_result:
12880 
  """
12881 
  Attributes:
12882 
   - success
12883 
  """
12884 
 
12885 
  thrift_spec = (
12886 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12887 
  )
12888 
 
12889 
  def __init__(self, success=None,):
12890 
    self.success = success
12891 
 
12892 
  def read(self, iprot):
12893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12895 
      return
12896 
    iprot.readStructBegin()
12897 
    while True:
12898 
      (fname, ftype, fid) = iprot.readFieldBegin()
12899 
      if ftype == TType.STOP:
12900 
        break
12901 
      if fid == 0:
12902 
        if ftype == TType.LIST:
12903 
          self.success = []
6850 kshitij.so 12904 
          (_etype224, _size221) = iprot.readListBegin()
12905 
          for _i225 in xrange(_size221):
12906 
            _elem226 = Source()
12907 
            _elem226.read(iprot)
12908 
            self.success.append(_elem226)
5944 mandeep.dh 12909 
          iprot.readListEnd()
12910 
        else:
12911 
          iprot.skip(ftype)
12912 
      else:
12913 
        iprot.skip(ftype)
12914 
      iprot.readFieldEnd()
12915 
    iprot.readStructEnd()
12916 
 
12917 
  def write(self, oprot):
12918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12920 
      return
12921 
    oprot.writeStructBegin('getAllSources_result')
12922 
    if self.success is not None:
12923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12924 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12925 
      for iter227 in self.success:
12926 
        iter227.write(oprot)
5944 mandeep.dh 12927 
      oprot.writeListEnd()
12928 
      oprot.writeFieldEnd()
12929 
    oprot.writeFieldStop()
12930 
    oprot.writeStructEnd()
12931 
 
12932 
  def validate(self):
12933 
    return
12934 
 
12935 
 
12936 
  def __repr__(self):
12937 
    L = ['%s=%r' % (key, value)
12938 
      for key, value in self.__dict__.iteritems()]
12939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12940 
 
12941 
  def __eq__(self, other):
12942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12943 
 
12944 
  def __ne__(self, other):
12945 
    return not (self == other)
12946 
 
12947 
class getItemPricingBySource_args:
12948 
  """
12949 
  Attributes:
12950 
   - itemId
12951 
   - sourceId
12952 
  """
12953 
 
12954 
  thrift_spec = (
12955 
    None, # 0
12956 
    (1, TType.I64, 'itemId', None, None, ), # 1
12957 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12958 
  )
12959 
 
12960 
  def __init__(self, itemId=None, sourceId=None,):
12961 
    self.itemId = itemId
12962 
    self.sourceId = sourceId
12963 
 
12964 
  def read(self, iprot):
12965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12967 
      return
12968 
    iprot.readStructBegin()
12969 
    while True:
12970 
      (fname, ftype, fid) = iprot.readFieldBegin()
12971 
      if ftype == TType.STOP:
12972 
        break
12973 
      if fid == 1:
12974 
        if ftype == TType.I64:
12975 
          self.itemId = iprot.readI64();
12976 
        else:
12977 
          iprot.skip(ftype)
12978 
      elif fid == 2:
12979 
        if ftype == TType.I64:
12980 
          self.sourceId = iprot.readI64();
12981 
        else:
12982 
          iprot.skip(ftype)
12983 
      else:
12984 
        iprot.skip(ftype)
12985 
      iprot.readFieldEnd()
12986 
    iprot.readStructEnd()
12987 
 
12988 
  def write(self, oprot):
12989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12991 
      return
12992 
    oprot.writeStructBegin('getItemPricingBySource_args')
12993 
    if self.itemId is not None:
12994 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12995 
      oprot.writeI64(self.itemId)
12996 
      oprot.writeFieldEnd()
12997 
    if self.sourceId is not None:
12998 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12999 
      oprot.writeI64(self.sourceId)
13000 
      oprot.writeFieldEnd()
13001 
    oprot.writeFieldStop()
13002 
    oprot.writeStructEnd()
13003 
 
13004 
  def validate(self):
13005 
    return
13006 
 
13007 
 
13008 
  def __repr__(self):
13009 
    L = ['%s=%r' % (key, value)
13010 
      for key, value in self.__dict__.iteritems()]
13011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13012 
 
13013 
  def __eq__(self, other):
13014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13015 
 
13016 
  def __ne__(self, other):
13017 
    return not (self == other)
13018 
 
13019 
class getItemPricingBySource_result:
13020 
  """
13021 
  Attributes:
13022 
   - success
13023 
   - cex
13024 
  """
13025 
 
13026 
  thrift_spec = (
13027 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13028 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13029 
  )
13030 
 
13031 
  def __init__(self, success=None, cex=None,):
13032 
    self.success = success
13033 
    self.cex = cex
13034 
 
13035 
  def read(self, iprot):
13036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13038 
      return
13039 
    iprot.readStructBegin()
13040 
    while True:
13041 
      (fname, ftype, fid) = iprot.readFieldBegin()
13042 
      if ftype == TType.STOP:
13043 
        break
13044 
      if fid == 0:
13045 
        if ftype == TType.STRUCT:
13046 
          self.success = SourceItemPricing()
13047 
          self.success.read(iprot)
13048 
        else:
13049 
          iprot.skip(ftype)
13050 
      elif fid == 1:
13051 
        if ftype == TType.STRUCT:
13052 
          self.cex = CatalogServiceException()
13053 
          self.cex.read(iprot)
13054 
        else:
13055 
          iprot.skip(ftype)
13056 
      else:
13057 
        iprot.skip(ftype)
13058 
      iprot.readFieldEnd()
13059 
    iprot.readStructEnd()
13060 
 
13061 
  def write(self, oprot):
13062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13064 
      return
13065 
    oprot.writeStructBegin('getItemPricingBySource_result')
13066 
    if self.success is not None:
13067 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13068 
      self.success.write(oprot)
13069 
      oprot.writeFieldEnd()
13070 
    if self.cex is not None:
13071 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13072 
      self.cex.write(oprot)
13073 
      oprot.writeFieldEnd()
13074 
    oprot.writeFieldStop()
13075 
    oprot.writeStructEnd()
13076 
 
13077 
  def validate(self):
13078 
    return
13079 
 
13080 
 
13081 
  def __repr__(self):
13082 
    L = ['%s=%r' % (key, value)
13083 
      for key, value in self.__dict__.iteritems()]
13084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13085 
 
13086 
  def __eq__(self, other):
13087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13088 
 
13089 
  def __ne__(self, other):
13090 
    return not (self == other)
13091 
 
13092 
class addSourceItemPricing_args:
13093 
  """
13094 
  Attributes:
13095 
   - sourceItemPricing
13096 
  """
13097 
 
13098 
  thrift_spec = (
13099 
    None, # 0
13100 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13101 
  )
13102 
 
13103 
  def __init__(self, sourceItemPricing=None,):
13104 
    self.sourceItemPricing = sourceItemPricing
13105 
 
13106 
  def read(self, iprot):
13107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13109 
      return
13110 
    iprot.readStructBegin()
13111 
    while True:
13112 
      (fname, ftype, fid) = iprot.readFieldBegin()
13113 
      if ftype == TType.STOP:
13114 
        break
13115 
      if fid == 1:
13116 
        if ftype == TType.STRUCT:
13117 
          self.sourceItemPricing = SourceItemPricing()
13118 
          self.sourceItemPricing.read(iprot)
13119 
        else:
13120 
          iprot.skip(ftype)
13121 
      else:
13122 
        iprot.skip(ftype)
13123 
      iprot.readFieldEnd()
13124 
    iprot.readStructEnd()
13125 
 
13126 
  def write(self, oprot):
13127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13129 
      return
13130 
    oprot.writeStructBegin('addSourceItemPricing_args')
13131 
    if self.sourceItemPricing is not None:
13132 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13133 
      self.sourceItemPricing.write(oprot)
13134 
      oprot.writeFieldEnd()
13135 
    oprot.writeFieldStop()
13136 
    oprot.writeStructEnd()
13137 
 
13138 
  def validate(self):
13139 
    return
13140 
 
13141 
 
13142 
  def __repr__(self):
13143 
    L = ['%s=%r' % (key, value)
13144 
      for key, value in self.__dict__.iteritems()]
13145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13146 
 
13147 
  def __eq__(self, other):
13148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13149 
 
13150 
  def __ne__(self, other):
13151 
    return not (self == other)
13152 
 
13153 
class addSourceItemPricing_result:
13154 
  """
13155 
  Attributes:
13156 
   - cex
13157 
  """
13158 
 
13159 
  thrift_spec = (
13160 
    None, # 0
13161 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13162 
  )
13163 
 
13164 
  def __init__(self, cex=None,):
13165 
    self.cex = cex
13166 
 
13167 
  def read(self, iprot):
13168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13170 
      return
13171 
    iprot.readStructBegin()
13172 
    while True:
13173 
      (fname, ftype, fid) = iprot.readFieldBegin()
13174 
      if ftype == TType.STOP:
13175 
        break
13176 
      if fid == 1:
13177 
        if ftype == TType.STRUCT:
13178 
          self.cex = CatalogServiceException()
13179 
          self.cex.read(iprot)
13180 
        else:
13181 
          iprot.skip(ftype)
13182 
      else:
13183 
        iprot.skip(ftype)
13184 
      iprot.readFieldEnd()
13185 
    iprot.readStructEnd()
13186 
 
13187 
  def write(self, oprot):
13188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13190 
      return
13191 
    oprot.writeStructBegin('addSourceItemPricing_result')
13192 
    if self.cex is not None:
13193 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13194 
      self.cex.write(oprot)
13195 
      oprot.writeFieldEnd()
13196 
    oprot.writeFieldStop()
13197 
    oprot.writeStructEnd()
13198 
 
13199 
  def validate(self):
13200 
    return
13201 
 
13202 
 
13203 
  def __repr__(self):
13204 
    L = ['%s=%r' % (key, value)
13205 
      for key, value in self.__dict__.iteritems()]
13206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13207 
 
13208 
  def __eq__(self, other):
13209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13210 
 
13211 
  def __ne__(self, other):
13212 
    return not (self == other)
13213 
 
13214 
class getAllSourcePricing_args:
13215 
  """
13216 
  Attributes:
13217 
   - itemId
13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
13222 
    (1, TType.I64, 'itemId', None, None, ), # 1
13223 
  )
13224 
 
13225 
  def __init__(self, itemId=None,):
13226 
    self.itemId = itemId
13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      if fid == 1:
13238 
        if ftype == TType.I64:
13239 
          self.itemId = iprot.readI64();
13240 
        else:
13241 
          iprot.skip(ftype)
13242 
      else:
13243 
        iprot.skip(ftype)
13244 
      iprot.readFieldEnd()
13245 
    iprot.readStructEnd()
13246 
 
13247 
  def write(self, oprot):
13248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13250 
      return
13251 
    oprot.writeStructBegin('getAllSourcePricing_args')
13252 
    if self.itemId is not None:
13253 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13254 
      oprot.writeI64(self.itemId)
13255 
      oprot.writeFieldEnd()
13256 
    oprot.writeFieldStop()
13257 
    oprot.writeStructEnd()
13258 
 
13259 
  def validate(self):
13260 
    return
13261 
 
13262 
 
13263 
  def __repr__(self):
13264 
    L = ['%s=%r' % (key, value)
13265 
      for key, value in self.__dict__.iteritems()]
13266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13267 
 
13268 
  def __eq__(self, other):
13269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13270 
 
13271 
  def __ne__(self, other):
13272 
    return not (self == other)
13273 
 
13274 
class getAllSourcePricing_result:
13275 
  """
13276 
  Attributes:
13277 
   - success
13278 
   - cex
13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13283 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13284 
  )
13285 
 
13286 
  def __init__(self, success=None, cex=None,):
13287 
    self.success = success
13288 
    self.cex = cex
13289 
 
13290 
  def read(self, iprot):
13291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13293 
      return
13294 
    iprot.readStructBegin()
13295 
    while True:
13296 
      (fname, ftype, fid) = iprot.readFieldBegin()
13297 
      if ftype == TType.STOP:
13298 
        break
13299 
      if fid == 0:
13300 
        if ftype == TType.LIST:
13301 
          self.success = []
6850 kshitij.so 13302 
          (_etype231, _size228) = iprot.readListBegin()
13303 
          for _i232 in xrange(_size228):
13304 
            _elem233 = SourceItemPricing()
13305 
            _elem233.read(iprot)
13306 
            self.success.append(_elem233)
5944 mandeep.dh 13307 
          iprot.readListEnd()
13308 
        else:
13309 
          iprot.skip(ftype)
13310 
      elif fid == 1:
13311 
        if ftype == TType.STRUCT:
13312 
          self.cex = CatalogServiceException()
13313 
          self.cex.read(iprot)
13314 
        else:
13315 
          iprot.skip(ftype)
13316 
      else:
13317 
        iprot.skip(ftype)
13318 
      iprot.readFieldEnd()
13319 
    iprot.readStructEnd()
13320 
 
13321 
  def write(self, oprot):
13322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13324 
      return
13325 
    oprot.writeStructBegin('getAllSourcePricing_result')
13326 
    if self.success is not None:
13327 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13328 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13329 
      for iter234 in self.success:
13330 
        iter234.write(oprot)
5944 mandeep.dh 13331 
      oprot.writeListEnd()
13332 
      oprot.writeFieldEnd()
13333 
    if self.cex is not None:
13334 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13335 
      self.cex.write(oprot)
13336 
      oprot.writeFieldEnd()
13337 
    oprot.writeFieldStop()
13338 
    oprot.writeStructEnd()
13339 
 
13340 
  def validate(self):
13341 
    return
13342 
 
13343 
 
13344 
  def __repr__(self):
13345 
    L = ['%s=%r' % (key, value)
13346 
      for key, value in self.__dict__.iteritems()]
13347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13348 
 
13349 
  def __eq__(self, other):
13350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13351 
 
13352 
  def __ne__(self, other):
13353 
    return not (self == other)
13354 
 
13355 
class getItemForSource_args:
13356 
  """
13357 
  Attributes:
13358 
   - item_id
13359 
   - sourceId
13360 
  """
13361 
 
13362 
  thrift_spec = (
13363 
    None, # 0
13364 
    (1, TType.I64, 'item_id', None, None, ), # 1
13365 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13366 
  )
13367 
 
13368 
  def __init__(self, item_id=None, sourceId=None,):
13369 
    self.item_id = item_id
13370 
    self.sourceId = sourceId
13371 
 
13372 
  def read(self, iprot):
13373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13375 
      return
13376 
    iprot.readStructBegin()
13377 
    while True:
13378 
      (fname, ftype, fid) = iprot.readFieldBegin()
13379 
      if ftype == TType.STOP:
13380 
        break
13381 
      if fid == 1:
13382 
        if ftype == TType.I64:
13383 
          self.item_id = iprot.readI64();
13384 
        else:
13385 
          iprot.skip(ftype)
13386 
      elif fid == 2:
13387 
        if ftype == TType.I64:
13388 
          self.sourceId = iprot.readI64();
13389 
        else:
13390 
          iprot.skip(ftype)
13391 
      else:
13392 
        iprot.skip(ftype)
13393 
      iprot.readFieldEnd()
13394 
    iprot.readStructEnd()
13395 
 
13396 
  def write(self, oprot):
13397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13399 
      return
13400 
    oprot.writeStructBegin('getItemForSource_args')
13401 
    if self.item_id is not None:
13402 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13403 
      oprot.writeI64(self.item_id)
13404 
      oprot.writeFieldEnd()
13405 
    if self.sourceId is not None:
13406 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13407 
      oprot.writeI64(self.sourceId)
13408 
      oprot.writeFieldEnd()
13409 
    oprot.writeFieldStop()
13410 
    oprot.writeStructEnd()
13411 
 
13412 
  def validate(self):
13413 
    return
13414 
 
13415 
 
13416 
  def __repr__(self):
13417 
    L = ['%s=%r' % (key, value)
13418 
      for key, value in self.__dict__.iteritems()]
13419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13420 
 
13421 
  def __eq__(self, other):
13422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13423 
 
13424 
  def __ne__(self, other):
13425 
    return not (self == other)
13426 
 
13427 
class getItemForSource_result:
13428 
  """
13429 
  Attributes:
13430 
   - success
13431 
   - cex
13432 
  """
13433 
 
13434 
  thrift_spec = (
13435 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13436 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13437 
  )
13438 
 
13439 
  def __init__(self, success=None, cex=None,):
13440 
    self.success = success
13441 
    self.cex = cex
13442 
 
13443 
  def read(self, iprot):
13444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13446 
      return
13447 
    iprot.readStructBegin()
13448 
    while True:
13449 
      (fname, ftype, fid) = iprot.readFieldBegin()
13450 
      if ftype == TType.STOP:
13451 
        break
13452 
      if fid == 0:
13453 
        if ftype == TType.STRUCT:
13454 
          self.success = Item()
13455 
          self.success.read(iprot)
13456 
        else:
13457 
          iprot.skip(ftype)
13458 
      elif fid == 1:
13459 
        if ftype == TType.STRUCT:
13460 
          self.cex = CatalogServiceException()
13461 
          self.cex.read(iprot)
13462 
        else:
13463 
          iprot.skip(ftype)
13464 
      else:
13465 
        iprot.skip(ftype)
13466 
      iprot.readFieldEnd()
13467 
    iprot.readStructEnd()
13468 
 
13469 
  def write(self, oprot):
13470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13472 
      return
13473 
    oprot.writeStructBegin('getItemForSource_result')
13474 
    if self.success is not None:
13475 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13476 
      self.success.write(oprot)
13477 
      oprot.writeFieldEnd()
13478 
    if self.cex is not None:
13479 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13480 
      self.cex.write(oprot)
13481 
      oprot.writeFieldEnd()
13482 
    oprot.writeFieldStop()
13483 
    oprot.writeStructEnd()
13484 
 
13485 
  def validate(self):
13486 
    return
13487 
 
13488 
 
13489 
  def __repr__(self):
13490 
    L = ['%s=%r' % (key, value)
13491 
      for key, value in self.__dict__.iteritems()]
13492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13493 
 
13494 
  def __eq__(self, other):
13495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13496 
 
13497 
  def __ne__(self, other):
13498 
    return not (self == other)
13499 
 
13500 
class searchItemsInRange_args:
13501 
  """
13502 
  Attributes:
13503 
   - searchTerms
13504 
   - offset
13505 
   - limit
13506 
  """
13507 
 
13508 
  thrift_spec = (
13509 
    None, # 0
13510 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13511 
    (2, TType.I64, 'offset', None, None, ), # 2
13512 
    (3, TType.I64, 'limit', None, None, ), # 3
13513 
  )
13514 
 
13515 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13516 
    self.searchTerms = searchTerms
13517 
    self.offset = offset
13518 
    self.limit = limit
13519 
 
13520 
  def read(self, iprot):
13521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13523 
      return
13524 
    iprot.readStructBegin()
13525 
    while True:
13526 
      (fname, ftype, fid) = iprot.readFieldBegin()
13527 
      if ftype == TType.STOP:
13528 
        break
13529 
      if fid == 1:
13530 
        if ftype == TType.LIST:
13531 
          self.searchTerms = []
6850 kshitij.so 13532 
          (_etype238, _size235) = iprot.readListBegin()
13533 
          for _i239 in xrange(_size235):
13534 
            _elem240 = iprot.readString();
13535 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13536 
          iprot.readListEnd()
13537 
        else:
13538 
          iprot.skip(ftype)
13539 
      elif fid == 2:
13540 
        if ftype == TType.I64:
13541 
          self.offset = iprot.readI64();
13542 
        else:
13543 
          iprot.skip(ftype)
13544 
      elif fid == 3:
13545 
        if ftype == TType.I64:
13546 
          self.limit = iprot.readI64();
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
13558 
    oprot.writeStructBegin('searchItemsInRange_args')
13559 
    if self.searchTerms is not None:
13560 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13561 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13562 
      for iter241 in self.searchTerms:
13563 
        oprot.writeString(iter241)
5944 mandeep.dh 13564 
      oprot.writeListEnd()
13565 
      oprot.writeFieldEnd()
13566 
    if self.offset is not None:
13567 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13568 
      oprot.writeI64(self.offset)
13569 
      oprot.writeFieldEnd()
13570 
    if self.limit is not None:
13571 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13572 
      oprot.writeI64(self.limit)
13573 
      oprot.writeFieldEnd()
13574 
    oprot.writeFieldStop()
13575 
    oprot.writeStructEnd()
13576 
 
13577 
  def validate(self):
13578 
    return
13579 
 
13580 
 
13581 
  def __repr__(self):
13582 
    L = ['%s=%r' % (key, value)
13583 
      for key, value in self.__dict__.iteritems()]
13584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13585 
 
13586 
  def __eq__(self, other):
13587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13588 
 
13589 
  def __ne__(self, other):
13590 
    return not (self == other)
13591 
 
13592 
class searchItemsInRange_result:
13593 
  """
13594 
  Attributes:
13595 
   - success
13596 
  """
13597 
 
13598 
  thrift_spec = (
13599 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13600 
  )
13601 
 
13602 
  def __init__(self, success=None,):
13603 
    self.success = success
13604 
 
13605 
  def read(self, iprot):
13606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13608 
      return
13609 
    iprot.readStructBegin()
13610 
    while True:
13611 
      (fname, ftype, fid) = iprot.readFieldBegin()
13612 
      if ftype == TType.STOP:
13613 
        break
13614 
      if fid == 0:
13615 
        if ftype == TType.LIST:
13616 
          self.success = []
6850 kshitij.so 13617 
          (_etype245, _size242) = iprot.readListBegin()
13618 
          for _i246 in xrange(_size242):
13619 
            _elem247 = Item()
13620 
            _elem247.read(iprot)
13621 
            self.success.append(_elem247)
5944 mandeep.dh 13622 
          iprot.readListEnd()
13623 
        else:
13624 
          iprot.skip(ftype)
13625 
      else:
13626 
        iprot.skip(ftype)
13627 
      iprot.readFieldEnd()
13628 
    iprot.readStructEnd()
13629 
 
13630 
  def write(self, oprot):
13631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13633 
      return
13634 
    oprot.writeStructBegin('searchItemsInRange_result')
13635 
    if self.success is not None:
13636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13638 
      for iter248 in self.success:
13639 
        iter248.write(oprot)
5944 mandeep.dh 13640 
      oprot.writeListEnd()
13641 
      oprot.writeFieldEnd()
13642 
    oprot.writeFieldStop()
13643 
    oprot.writeStructEnd()
13644 
 
13645 
  def validate(self):
13646 
    return
13647 
 
13648 
 
13649 
  def __repr__(self):
13650 
    L = ['%s=%r' % (key, value)
13651 
      for key, value in self.__dict__.iteritems()]
13652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13653 
 
13654 
  def __eq__(self, other):
13655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13656 
 
13657 
  def __ne__(self, other):
13658 
    return not (self == other)
13659 
 
13660 
class getSearchResultCount_args:
13661 
  """
13662 
  Attributes:
13663 
   - searchTerms
13664 
  """
13665 
 
13666 
  thrift_spec = (
13667 
    None, # 0
13668 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13669 
  )
13670 
 
13671 
  def __init__(self, searchTerms=None,):
13672 
    self.searchTerms = searchTerms
13673 
 
13674 
  def read(self, iprot):
13675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13677 
      return
13678 
    iprot.readStructBegin()
13679 
    while True:
13680 
      (fname, ftype, fid) = iprot.readFieldBegin()
13681 
      if ftype == TType.STOP:
13682 
        break
13683 
      if fid == 1:
13684 
        if ftype == TType.LIST:
13685 
          self.searchTerms = []
6850 kshitij.so 13686 
          (_etype252, _size249) = iprot.readListBegin()
13687 
          for _i253 in xrange(_size249):
13688 
            _elem254 = iprot.readString();
13689 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13690 
          iprot.readListEnd()
13691 
        else:
13692 
          iprot.skip(ftype)
13693 
      else:
13694 
        iprot.skip(ftype)
13695 
      iprot.readFieldEnd()
13696 
    iprot.readStructEnd()
13697 
 
13698 
  def write(self, oprot):
13699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13701 
      return
13702 
    oprot.writeStructBegin('getSearchResultCount_args')
13703 
    if self.searchTerms is not None:
13704 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13705 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13706 
      for iter255 in self.searchTerms:
13707 
        oprot.writeString(iter255)
5944 mandeep.dh 13708 
      oprot.writeListEnd()
13709 
      oprot.writeFieldEnd()
13710 
    oprot.writeFieldStop()
13711 
    oprot.writeStructEnd()
13712 
 
13713 
  def validate(self):
13714 
    return
13715 
 
13716 
 
13717 
  def __repr__(self):
13718 
    L = ['%s=%r' % (key, value)
13719 
      for key, value in self.__dict__.iteritems()]
13720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13721 
 
13722 
  def __eq__(self, other):
13723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13724 
 
13725 
  def __ne__(self, other):
13726 
    return not (self == other)
13727 
 
13728 
class getSearchResultCount_result:
13729 
  """
13730 
  Attributes:
13731 
   - success
13732 
  """
13733 
 
13734 
  thrift_spec = (
13735 
    (0, TType.I32, 'success', None, None, ), # 0
13736 
  )
13737 
 
13738 
  def __init__(self, success=None,):
13739 
    self.success = success
13740 
 
13741 
  def read(self, iprot):
13742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13744 
      return
13745 
    iprot.readStructBegin()
13746 
    while True:
13747 
      (fname, ftype, fid) = iprot.readFieldBegin()
13748 
      if ftype == TType.STOP:
13749 
        break
13750 
      if fid == 0:
13751 
        if ftype == TType.I32:
13752 
          self.success = iprot.readI32();
13753 
        else:
13754 
          iprot.skip(ftype)
13755 
      else:
13756 
        iprot.skip(ftype)
13757 
      iprot.readFieldEnd()
13758 
    iprot.readStructEnd()
13759 
 
13760 
  def write(self, oprot):
13761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13763 
      return
13764 
    oprot.writeStructBegin('getSearchResultCount_result')
13765 
    if self.success is not None:
13766 
      oprot.writeFieldBegin('success', TType.I32, 0)
13767 
      oprot.writeI32(self.success)
13768 
      oprot.writeFieldEnd()
13769 
    oprot.writeFieldStop()
13770 
    oprot.writeStructEnd()
13771 
 
13772 
  def validate(self):
13773 
    return
13774 
 
13775 
 
13776 
  def __repr__(self):
13777 
    L = ['%s=%r' % (key, value)
13778 
      for key, value in self.__dict__.iteritems()]
13779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13780 
 
13781 
  def __eq__(self, other):
13782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13783 
 
13784 
  def __ne__(self, other):
13785 
    return not (self == other)
13786 
 
13787 
class getProductNotifications_args:
13788 
  """
13789 
  Attributes:
13790 
   - startDateTime
13791 
  """
13792 
 
13793 
  thrift_spec = (
13794 
    None, # 0
13795 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13796 
  )
13797 
 
13798 
  def __init__(self, startDateTime=None,):
13799 
    self.startDateTime = startDateTime
13800 
 
13801 
  def read(self, iprot):
13802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13804 
      return
13805 
    iprot.readStructBegin()
13806 
    while True:
13807 
      (fname, ftype, fid) = iprot.readFieldBegin()
13808 
      if ftype == TType.STOP:
13809 
        break
13810 
      if fid == 1:
13811 
        if ftype == TType.I64:
13812 
          self.startDateTime = iprot.readI64();
13813 
        else:
13814 
          iprot.skip(ftype)
13815 
      else:
13816 
        iprot.skip(ftype)
13817 
      iprot.readFieldEnd()
13818 
    iprot.readStructEnd()
13819 
 
13820 
  def write(self, oprot):
13821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13823 
      return
13824 
    oprot.writeStructBegin('getProductNotifications_args')
13825 
    if self.startDateTime is not None:
13826 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13827 
      oprot.writeI64(self.startDateTime)
13828 
      oprot.writeFieldEnd()
13829 
    oprot.writeFieldStop()
13830 
    oprot.writeStructEnd()
13831 
 
13832 
  def validate(self):
13833 
    return
13834 
 
13835 
 
13836 
  def __repr__(self):
13837 
    L = ['%s=%r' % (key, value)
13838 
      for key, value in self.__dict__.iteritems()]
13839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13840 
 
13841 
  def __eq__(self, other):
13842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13843 
 
13844 
  def __ne__(self, other):
13845 
    return not (self == other)
13846 
 
13847 
class getProductNotifications_result:
13848 
  """
13849 
  Attributes:
13850 
   - success
13851 
  """
13852 
 
13853 
  thrift_spec = (
13854 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13855 
  )
13856 
 
13857 
  def __init__(self, success=None,):
13858 
    self.success = success
13859 
 
13860 
  def read(self, iprot):
13861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13863 
      return
13864 
    iprot.readStructBegin()
13865 
    while True:
13866 
      (fname, ftype, fid) = iprot.readFieldBegin()
13867 
      if ftype == TType.STOP:
13868 
        break
13869 
      if fid == 0:
13870 
        if ftype == TType.LIST:
13871 
          self.success = []
6850 kshitij.so 13872 
          (_etype259, _size256) = iprot.readListBegin()
13873 
          for _i260 in xrange(_size256):
13874 
            _elem261 = ProductNotificationRequest()
13875 
            _elem261.read(iprot)
13876 
            self.success.append(_elem261)
5944 mandeep.dh 13877 
          iprot.readListEnd()
13878 
        else:
13879 
          iprot.skip(ftype)
13880 
      else:
13881 
        iprot.skip(ftype)
13882 
      iprot.readFieldEnd()
13883 
    iprot.readStructEnd()
13884 
 
13885 
  def write(self, oprot):
13886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13888 
      return
13889 
    oprot.writeStructBegin('getProductNotifications_result')
13890 
    if self.success is not None:
13891 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13892 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13893 
      for iter262 in self.success:
13894 
        iter262.write(oprot)
5944 mandeep.dh 13895 
      oprot.writeListEnd()
13896 
      oprot.writeFieldEnd()
13897 
    oprot.writeFieldStop()
13898 
    oprot.writeStructEnd()
13899 
 
13900 
  def validate(self):
13901 
    return
13902 
 
13903 
 
13904 
  def __repr__(self):
13905 
    L = ['%s=%r' % (key, value)
13906 
      for key, value in self.__dict__.iteritems()]
13907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13908 
 
13909 
  def __eq__(self, other):
13910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13911 
 
13912 
  def __ne__(self, other):
13913 
    return not (self == other)
13914 
 
13915 
class getProductNotificationRequestCount_args:
13916 
  """
13917 
  Attributes:
13918 
   - startDateTime
13919 
  """
13920 
 
13921 
  thrift_spec = (
13922 
    None, # 0
13923 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13924 
  )
13925 
 
13926 
  def __init__(self, startDateTime=None,):
13927 
    self.startDateTime = startDateTime
13928 
 
13929 
  def read(self, iprot):
13930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13932 
      return
13933 
    iprot.readStructBegin()
13934 
    while True:
13935 
      (fname, ftype, fid) = iprot.readFieldBegin()
13936 
      if ftype == TType.STOP:
13937 
        break
13938 
      if fid == 1:
13939 
        if ftype == TType.I64:
13940 
          self.startDateTime = iprot.readI64();
13941 
        else:
13942 
          iprot.skip(ftype)
13943 
      else:
13944 
        iprot.skip(ftype)
13945 
      iprot.readFieldEnd()
13946 
    iprot.readStructEnd()
13947 
 
13948 
  def write(self, oprot):
13949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13951 
      return
13952 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13953 
    if self.startDateTime is not None:
13954 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13955 
      oprot.writeI64(self.startDateTime)
13956 
      oprot.writeFieldEnd()
13957 
    oprot.writeFieldStop()
13958 
    oprot.writeStructEnd()
13959 
 
13960 
  def validate(self):
13961 
    return
13962 
 
13963 
 
13964 
  def __repr__(self):
13965 
    L = ['%s=%r' % (key, value)
13966 
      for key, value in self.__dict__.iteritems()]
13967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13968 
 
13969 
  def __eq__(self, other):
13970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13971 
 
13972 
  def __ne__(self, other):
13973 
    return not (self == other)
13974 
 
13975 
class getProductNotificationRequestCount_result:
13976 
  """
13977 
  Attributes:
13978 
   - success
13979 
  """
13980 
 
13981 
  thrift_spec = (
13982 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13983 
  )
13984 
 
13985 
  def __init__(self, success=None,):
13986 
    self.success = success
13987 
 
13988 
  def read(self, iprot):
13989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13991 
      return
13992 
    iprot.readStructBegin()
13993 
    while True:
13994 
      (fname, ftype, fid) = iprot.readFieldBegin()
13995 
      if ftype == TType.STOP:
13996 
        break
13997 
      if fid == 0:
13998 
        if ftype == TType.LIST:
13999 
          self.success = []
6850 kshitij.so 14000 
          (_etype266, _size263) = iprot.readListBegin()
14001 
          for _i267 in xrange(_size263):
14002 
            _elem268 = ProductNotificationRequestCount()
14003 
            _elem268.read(iprot)
14004 
            self.success.append(_elem268)
5944 mandeep.dh 14005 
          iprot.readListEnd()
14006 
        else:
14007 
          iprot.skip(ftype)
14008 
      else:
14009 
        iprot.skip(ftype)
14010 
      iprot.readFieldEnd()
14011 
    iprot.readStructEnd()
14012 
 
14013 
  def write(self, oprot):
14014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14016 
      return
14017 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14018 
    if self.success is not None:
14019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14020 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 14021 
      for iter269 in self.success:
14022 
        iter269.write(oprot)
5944 mandeep.dh 14023 
      oprot.writeListEnd()
14024 
      oprot.writeFieldEnd()
14025 
    oprot.writeFieldStop()
14026 
    oprot.writeStructEnd()
14027 
 
14028 
  def validate(self):
14029 
    return
14030 
 
14031 
 
14032 
  def __repr__(self):
14033 
    L = ['%s=%r' % (key, value)
14034 
      for key, value in self.__dict__.iteritems()]
14035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14036 
 
14037 
  def __eq__(self, other):
14038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14039 
 
14040 
  def __ne__(self, other):
14041 
    return not (self == other)
14042 
 
14043 
class addAuthorizationLog_args:
14044 
  """
14045 
  Attributes:
14046 
   - itemId
14047 
   - username
14048 
   - reason
14049 
  """
14050 
 
14051 
  thrift_spec = (
14052 
    None, # 0
14053 
    (1, TType.I64, 'itemId', None, None, ), # 1
14054 
    (2, TType.STRING, 'username', None, None, ), # 2
14055 
    (3, TType.STRING, 'reason', None, None, ), # 3
14056 
  )
14057 
 
14058 
  def __init__(self, itemId=None, username=None, reason=None,):
14059 
    self.itemId = itemId
14060 
    self.username = username
14061 
    self.reason = reason
14062 
 
14063 
  def read(self, iprot):
14064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14066 
      return
14067 
    iprot.readStructBegin()
14068 
    while True:
14069 
      (fname, ftype, fid) = iprot.readFieldBegin()
14070 
      if ftype == TType.STOP:
14071 
        break
14072 
      if fid == 1:
14073 
        if ftype == TType.I64:
14074 
          self.itemId = iprot.readI64();
14075 
        else:
14076 
          iprot.skip(ftype)
14077 
      elif fid == 2:
14078 
        if ftype == TType.STRING:
14079 
          self.username = iprot.readString();
14080 
        else:
14081 
          iprot.skip(ftype)
14082 
      elif fid == 3:
14083 
        if ftype == TType.STRING:
14084 
          self.reason = iprot.readString();
14085 
        else:
14086 
          iprot.skip(ftype)
14087 
      else:
14088 
        iprot.skip(ftype)
14089 
      iprot.readFieldEnd()
14090 
    iprot.readStructEnd()
14091 
 
14092 
  def write(self, oprot):
14093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14095 
      return
14096 
    oprot.writeStructBegin('addAuthorizationLog_args')
14097 
    if self.itemId is not None:
14098 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14099 
      oprot.writeI64(self.itemId)
14100 
      oprot.writeFieldEnd()
14101 
    if self.username is not None:
14102 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14103 
      oprot.writeString(self.username)
14104 
      oprot.writeFieldEnd()
14105 
    if self.reason is not None:
14106 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14107 
      oprot.writeString(self.reason)
14108 
      oprot.writeFieldEnd()
14109 
    oprot.writeFieldStop()
14110 
    oprot.writeStructEnd()
14111 
 
14112 
  def validate(self):
14113 
    return
14114 
 
14115 
 
14116 
  def __repr__(self):
14117 
    L = ['%s=%r' % (key, value)
14118 
      for key, value in self.__dict__.iteritems()]
14119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14120 
 
14121 
  def __eq__(self, other):
14122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14123 
 
14124 
  def __ne__(self, other):
14125 
    return not (self == other)
14126 
 
14127 
class addAuthorizationLog_result:
14128 
  """
14129 
  Attributes:
14130 
   - success
14131 
   - cex
14132 
  """
14133 
 
14134 
  thrift_spec = (
14135 
    (0, TType.BOOL, 'success', None, None, ), # 0
14136 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14137 
  )
14138 
 
14139 
  def __init__(self, success=None, cex=None,):
14140 
    self.success = success
14141 
    self.cex = cex
14142 
 
14143 
  def read(self, iprot):
14144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14146 
      return
14147 
    iprot.readStructBegin()
14148 
    while True:
14149 
      (fname, ftype, fid) = iprot.readFieldBegin()
14150 
      if ftype == TType.STOP:
14151 
        break
14152 
      if fid == 0:
14153 
        if ftype == TType.BOOL:
14154 
          self.success = iprot.readBool();
14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      elif fid == 1:
14158 
        if ftype == TType.STRUCT:
14159 
          self.cex = CatalogServiceException()
14160 
          self.cex.read(iprot)
14161 
        else:
14162 
          iprot.skip(ftype)
14163 
      else:
14164 
        iprot.skip(ftype)
14165 
      iprot.readFieldEnd()
14166 
    iprot.readStructEnd()
14167 
 
14168 
  def write(self, oprot):
14169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14171 
      return
14172 
    oprot.writeStructBegin('addAuthorizationLog_result')
14173 
    if self.success is not None:
14174 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14175 
      oprot.writeBool(self.success)
14176 
      oprot.writeFieldEnd()
14177 
    if self.cex is not None:
14178 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14179 
      self.cex.write(oprot)
14180 
      oprot.writeFieldEnd()
14181 
    oprot.writeFieldStop()
14182 
    oprot.writeStructEnd()
14183 
 
14184 
  def validate(self):
14185 
    return
14186 
 
14187 
 
14188 
  def __repr__(self):
14189 
    L = ['%s=%r' % (key, value)
14190 
      for key, value in self.__dict__.iteritems()]
14191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14192 
 
14193 
  def __eq__(self, other):
14194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14195 
 
14196 
  def __ne__(self, other):
14197 
    return not (self == other)
14198 
 
14199 
class addupdateVoucherForItem_args:
14200 
  """
14201 
  Attributes:
14202 
   - catalog_item_id
14203 
   - voucherType
14204 
   - voucherAmount
14205 
  """
14206 
 
14207 
  thrift_spec = (
14208 
    None, # 0
14209 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14210 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14211 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14212 
  )
14213 
 
14214 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14215 
    self.catalog_item_id = catalog_item_id
14216 
    self.voucherType = voucherType
14217 
    self.voucherAmount = voucherAmount
14218 
 
14219 
  def read(self, iprot):
14220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14222 
      return
14223 
    iprot.readStructBegin()
14224 
    while True:
14225 
      (fname, ftype, fid) = iprot.readFieldBegin()
14226 
      if ftype == TType.STOP:
14227 
        break
14228 
      if fid == 1:
14229 
        if ftype == TType.I64:
14230 
          self.catalog_item_id = iprot.readI64();
14231 
        else:
14232 
          iprot.skip(ftype)
14233 
      elif fid == 2:
14234 
        if ftype == TType.I64:
14235 
          self.voucherType = iprot.readI64();
14236 
        else:
14237 
          iprot.skip(ftype)
14238 
      elif fid == 3:
14239 
        if ftype == TType.I64:
14240 
          self.voucherAmount = iprot.readI64();
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      else:
14244 
        iprot.skip(ftype)
14245 
      iprot.readFieldEnd()
14246 
    iprot.readStructEnd()
14247 
 
14248 
  def write(self, oprot):
14249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14251 
      return
14252 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14253 
    if self.catalog_item_id is not None:
14254 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14255 
      oprot.writeI64(self.catalog_item_id)
14256 
      oprot.writeFieldEnd()
14257 
    if self.voucherType is not None:
14258 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14259 
      oprot.writeI64(self.voucherType)
14260 
      oprot.writeFieldEnd()
14261 
    if self.voucherAmount is not None:
14262 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14263 
      oprot.writeI64(self.voucherAmount)
14264 
      oprot.writeFieldEnd()
14265 
    oprot.writeFieldStop()
14266 
    oprot.writeStructEnd()
14267 
 
14268 
  def validate(self):
14269 
    return
14270 
 
14271 
 
14272 
  def __repr__(self):
14273 
    L = ['%s=%r' % (key, value)
14274 
      for key, value in self.__dict__.iteritems()]
14275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14276 
 
14277 
  def __eq__(self, other):
14278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14279 
 
14280 
  def __ne__(self, other):
14281 
    return not (self == other)
14282 
 
14283 
class addupdateVoucherForItem_result:
14284 
  """
14285 
  Attributes:
14286 
   - success
14287 
   - cex
14288 
  """
14289 
 
14290 
  thrift_spec = (
14291 
    (0, TType.BOOL, 'success', None, None, ), # 0
14292 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14293 
  )
14294 
 
14295 
  def __init__(self, success=None, cex=None,):
14296 
    self.success = success
14297 
    self.cex = cex
14298 
 
14299 
  def read(self, iprot):
14300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14302 
      return
14303 
    iprot.readStructBegin()
14304 
    while True:
14305 
      (fname, ftype, fid) = iprot.readFieldBegin()
14306 
      if ftype == TType.STOP:
14307 
        break
14308 
      if fid == 0:
14309 
        if ftype == TType.BOOL:
14310 
          self.success = iprot.readBool();
14311 
        else:
14312 
          iprot.skip(ftype)
14313 
      elif fid == 1:
14314 
        if ftype == TType.STRUCT:
14315 
          self.cex = CatalogServiceException()
14316 
          self.cex.read(iprot)
14317 
        else:
14318 
          iprot.skip(ftype)
14319 
      else:
14320 
        iprot.skip(ftype)
14321 
      iprot.readFieldEnd()
14322 
    iprot.readStructEnd()
14323 
 
14324 
  def write(self, oprot):
14325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14327 
      return
14328 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14329 
    if self.success is not None:
14330 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14331 
      oprot.writeBool(self.success)
14332 
      oprot.writeFieldEnd()
14333 
    if self.cex is not None:
14334 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14335 
      self.cex.write(oprot)
14336 
      oprot.writeFieldEnd()
14337 
    oprot.writeFieldStop()
14338 
    oprot.writeStructEnd()
14339 
 
14340 
  def validate(self):
14341 
    return
14342 
 
14343 
 
14344 
  def __repr__(self):
14345 
    L = ['%s=%r' % (key, value)
14346 
      for key, value in self.__dict__.iteritems()]
14347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14348 
 
14349 
  def __eq__(self, other):
14350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14351 
 
14352 
  def __ne__(self, other):
14353 
    return not (self == other)
14354 
 
14355 
class deleteVoucherForItem_args:
14356 
  """
14357 
  Attributes:
14358 
   - catalog_item_id
14359 
   - voucherType
14360 
  """
14361 
 
14362 
  thrift_spec = (
14363 
    None, # 0
14364 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14365 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14366 
  )
14367 
 
14368 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14369 
    self.catalog_item_id = catalog_item_id
14370 
    self.voucherType = voucherType
14371 
 
14372 
  def read(self, iprot):
14373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14375 
      return
14376 
    iprot.readStructBegin()
14377 
    while True:
14378 
      (fname, ftype, fid) = iprot.readFieldBegin()
14379 
      if ftype == TType.STOP:
14380 
        break
14381 
      if fid == 1:
14382 
        if ftype == TType.I64:
14383 
          self.catalog_item_id = iprot.readI64();
14384 
        else:
14385 
          iprot.skip(ftype)
14386 
      elif fid == 2:
14387 
        if ftype == TType.I64:
14388 
          self.voucherType = iprot.readI64();
14389 
        else:
14390 
          iprot.skip(ftype)
14391 
      else:
14392 
        iprot.skip(ftype)
14393 
      iprot.readFieldEnd()
14394 
    iprot.readStructEnd()
14395 
 
14396 
  def write(self, oprot):
14397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14399 
      return
14400 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14401 
    if self.catalog_item_id is not None:
14402 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14403 
      oprot.writeI64(self.catalog_item_id)
14404 
      oprot.writeFieldEnd()
14405 
    if self.voucherType is not None:
14406 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14407 
      oprot.writeI64(self.voucherType)
14408 
      oprot.writeFieldEnd()
14409 
    oprot.writeFieldStop()
14410 
    oprot.writeStructEnd()
14411 
 
14412 
  def validate(self):
14413 
    return
14414 
 
14415 
 
14416 
  def __repr__(self):
14417 
    L = ['%s=%r' % (key, value)
14418 
      for key, value in self.__dict__.iteritems()]
14419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14420 
 
14421 
  def __eq__(self, other):
14422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14423 
 
14424 
  def __ne__(self, other):
14425 
    return not (self == other)
14426 
 
14427 
class deleteVoucherForItem_result:
14428 
  """
14429 
  Attributes:
14430 
   - success
14431 
   - cex
14432 
  """
14433 
 
14434 
  thrift_spec = (
14435 
    (0, TType.BOOL, 'success', None, None, ), # 0
14436 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14437 
  )
14438 
 
14439 
  def __init__(self, success=None, cex=None,):
14440 
    self.success = success
14441 
    self.cex = cex
14442 
 
14443 
  def read(self, iprot):
14444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14446 
      return
14447 
    iprot.readStructBegin()
14448 
    while True:
14449 
      (fname, ftype, fid) = iprot.readFieldBegin()
14450 
      if ftype == TType.STOP:
14451 
        break
14452 
      if fid == 0:
14453 
        if ftype == TType.BOOL:
14454 
          self.success = iprot.readBool();
14455 
        else:
14456 
          iprot.skip(ftype)
14457 
      elif fid == 1:
14458 
        if ftype == TType.STRUCT:
14459 
          self.cex = CatalogServiceException()
14460 
          self.cex.read(iprot)
14461 
        else:
14462 
          iprot.skip(ftype)
14463 
      else:
14464 
        iprot.skip(ftype)
14465 
      iprot.readFieldEnd()
14466 
    iprot.readStructEnd()
14467 
 
14468 
  def write(self, oprot):
14469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14471 
      return
14472 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14473 
    if self.success is not None:
14474 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14475 
      oprot.writeBool(self.success)
14476 
      oprot.writeFieldEnd()
14477 
    if self.cex is not None:
14478 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14479 
      self.cex.write(oprot)
14480 
      oprot.writeFieldEnd()
14481 
    oprot.writeFieldStop()
14482 
    oprot.writeStructEnd()
14483 
 
14484 
  def validate(self):
14485 
    return
14486 
 
14487 
 
14488 
  def __repr__(self):
14489 
    L = ['%s=%r' % (key, value)
14490 
      for key, value in self.__dict__.iteritems()]
14491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14492 
 
14493 
  def __eq__(self, other):
14494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14495 
 
14496 
  def __ne__(self, other):
14497 
    return not (self == other)
14498 
 
14499 
class getVoucherAmount_args:
14500 
  """
14501 
  Attributes:
14502 
   - itemId
14503 
   - voucherType
14504 
  """
14505 
 
14506 
  thrift_spec = (
14507 
    None, # 0
14508 
    (1, TType.I64, 'itemId', None, None, ), # 1
14509 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14510 
  )
14511 
 
14512 
  def __init__(self, itemId=None, voucherType=None,):
14513 
    self.itemId = itemId
14514 
    self.voucherType = voucherType
14515 
 
14516 
  def read(self, iprot):
14517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14519 
      return
14520 
    iprot.readStructBegin()
14521 
    while True:
14522 
      (fname, ftype, fid) = iprot.readFieldBegin()
14523 
      if ftype == TType.STOP:
14524 
        break
14525 
      if fid == 1:
14526 
        if ftype == TType.I64:
14527 
          self.itemId = iprot.readI64();
14528 
        else:
14529 
          iprot.skip(ftype)
14530 
      elif fid == 2:
14531 
        if ftype == TType.I64:
14532 
          self.voucherType = iprot.readI64();
14533 
        else:
14534 
          iprot.skip(ftype)
14535 
      else:
14536 
        iprot.skip(ftype)
14537 
      iprot.readFieldEnd()
14538 
    iprot.readStructEnd()
14539 
 
14540 
  def write(self, oprot):
14541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14543 
      return
14544 
    oprot.writeStructBegin('getVoucherAmount_args')
14545 
    if self.itemId is not None:
14546 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14547 
      oprot.writeI64(self.itemId)
14548 
      oprot.writeFieldEnd()
14549 
    if self.voucherType is not None:
14550 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14551 
      oprot.writeI64(self.voucherType)
14552 
      oprot.writeFieldEnd()
14553 
    oprot.writeFieldStop()
14554 
    oprot.writeStructEnd()
14555 
 
14556 
  def validate(self):
14557 
    return
14558 
 
14559 
 
14560 
  def __repr__(self):
14561 
    L = ['%s=%r' % (key, value)
14562 
      for key, value in self.__dict__.iteritems()]
14563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14564 
 
14565 
  def __eq__(self, other):
14566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14567 
 
14568 
  def __ne__(self, other):
14569 
    return not (self == other)
14570 
 
14571 
class getVoucherAmount_result:
14572 
  """
14573 
  Attributes:
14574 
   - success
14575 
  """
14576 
 
14577 
  thrift_spec = (
14578 
    (0, TType.I64, 'success', None, None, ), # 0
14579 
  )
14580 
 
14581 
  def __init__(self, success=None,):
14582 
    self.success = success
14583 
 
14584 
  def read(self, iprot):
14585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14587 
      return
14588 
    iprot.readStructBegin()
14589 
    while True:
14590 
      (fname, ftype, fid) = iprot.readFieldBegin()
14591 
      if ftype == TType.STOP:
14592 
        break
14593 
      if fid == 0:
14594 
        if ftype == TType.I64:
14595 
          self.success = iprot.readI64();
14596 
        else:
14597 
          iprot.skip(ftype)
14598 
      else:
14599 
        iprot.skip(ftype)
14600 
      iprot.readFieldEnd()
14601 
    iprot.readStructEnd()
14602 
 
14603 
  def write(self, oprot):
14604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14606 
      return
14607 
    oprot.writeStructBegin('getVoucherAmount_result')
14608 
    if self.success is not None:
14609 
      oprot.writeFieldBegin('success', TType.I64, 0)
14610 
      oprot.writeI64(self.success)
14611 
      oprot.writeFieldEnd()
14612 
    oprot.writeFieldStop()
14613 
    oprot.writeStructEnd()
14614 
 
14615 
  def validate(self):
14616 
    return
14617 
 
14618 
 
14619 
  def __repr__(self):
14620 
    L = ['%s=%r' % (key, value)
14621 
      for key, value in self.__dict__.iteritems()]
14622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14623 
 
14624 
  def __eq__(self, other):
14625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14626 
 
14627 
  def __ne__(self, other):
14628 
    return not (self == other)
14629 
 
14630 
class getAllItemVouchers_args:
14631 
  """
14632 
  Attributes:
14633 
   - itemId
14634 
  """
14635 
 
14636 
  thrift_spec = (
14637 
    None, # 0
14638 
    (1, TType.I64, 'itemId', None, None, ), # 1
14639 
  )
14640 
 
14641 
  def __init__(self, itemId=None,):
14642 
    self.itemId = itemId
14643 
 
14644 
  def read(self, iprot):
14645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14647 
      return
14648 
    iprot.readStructBegin()
14649 
    while True:
14650 
      (fname, ftype, fid) = iprot.readFieldBegin()
14651 
      if ftype == TType.STOP:
14652 
        break
14653 
      if fid == 1:
14654 
        if ftype == TType.I64:
14655 
          self.itemId = iprot.readI64();
14656 
        else:
14657 
          iprot.skip(ftype)
14658 
      else:
14659 
        iprot.skip(ftype)
14660 
      iprot.readFieldEnd()
14661 
    iprot.readStructEnd()
14662 
 
14663 
  def write(self, oprot):
14664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14666 
      return
14667 
    oprot.writeStructBegin('getAllItemVouchers_args')
14668 
    if self.itemId is not None:
14669 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14670 
      oprot.writeI64(self.itemId)
14671 
      oprot.writeFieldEnd()
14672 
    oprot.writeFieldStop()
14673 
    oprot.writeStructEnd()
14674 
 
14675 
  def validate(self):
14676 
    return
14677 
 
14678 
 
14679 
  def __repr__(self):
14680 
    L = ['%s=%r' % (key, value)
14681 
      for key, value in self.__dict__.iteritems()]
14682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14683 
 
14684 
  def __eq__(self, other):
14685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14686 
 
14687 
  def __ne__(self, other):
14688 
    return not (self == other)
14689 
 
14690 
class getAllItemVouchers_result:
14691 
  """
14692 
  Attributes:
14693 
   - success
14694 
  """
14695 
 
14696 
  thrift_spec = (
14697 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14698 
  )
14699 
 
14700 
  def __init__(self, success=None,):
14701 
    self.success = success
14702 
 
14703 
  def read(self, iprot):
14704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14706 
      return
14707 
    iprot.readStructBegin()
14708 
    while True:
14709 
      (fname, ftype, fid) = iprot.readFieldBegin()
14710 
      if ftype == TType.STOP:
14711 
        break
14712 
      if fid == 0:
14713 
        if ftype == TType.LIST:
14714 
          self.success = []
7256 rajveer 14715 
          (_etype273, _size270) = iprot.readListBegin()
14716 
          for _i274 in xrange(_size270):
14717 
            _elem275 = VoucherItemMapping()
14718 
            _elem275.read(iprot)
14719 
            self.success.append(_elem275)
5944 mandeep.dh 14720 
          iprot.readListEnd()
14721 
        else:
14722 
          iprot.skip(ftype)
14723 
      else:
14724 
        iprot.skip(ftype)
14725 
      iprot.readFieldEnd()
14726 
    iprot.readStructEnd()
14727 
 
14728 
  def write(self, oprot):
14729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14731 
      return
14732 
    oprot.writeStructBegin('getAllItemVouchers_result')
14733 
    if self.success is not None:
14734 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14735 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14736 
      for iter276 in self.success:
14737 
        iter276.write(oprot)
5944 mandeep.dh 14738 
      oprot.writeListEnd()
14739 
      oprot.writeFieldEnd()
14740 
    oprot.writeFieldStop()
14741 
    oprot.writeStructEnd()
14742 
 
14743 
  def validate(self):
14744 
    return
14745 
 
14746 
 
14747 
  def __repr__(self):
14748 
    L = ['%s=%r' % (key, value)
14749 
      for key, value in self.__dict__.iteritems()]
14750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14751 
 
14752 
  def __eq__(self, other):
14753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14754 
 
14755 
  def __ne__(self, other):
14756 
    return not (self == other)
14757 
 
14758 
class isValidCatalogItemId_args:
14759 
  """
14760 
  Attributes:
14761 
   - catalog_item_id
14762 
  """
14763 
 
14764 
  thrift_spec = (
14765 
    None, # 0
14766 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14767 
  )
14768 
 
14769 
  def __init__(self, catalog_item_id=None,):
14770 
    self.catalog_item_id = catalog_item_id
14771 
 
14772 
  def read(self, iprot):
14773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14775 
      return
14776 
    iprot.readStructBegin()
14777 
    while True:
14778 
      (fname, ftype, fid) = iprot.readFieldBegin()
14779 
      if ftype == TType.STOP:
14780 
        break
14781 
      if fid == 1:
14782 
        if ftype == TType.I64:
14783 
          self.catalog_item_id = iprot.readI64();
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      else:
14787 
        iprot.skip(ftype)
14788 
      iprot.readFieldEnd()
14789 
    iprot.readStructEnd()
14790 
 
14791 
  def write(self, oprot):
14792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14794 
      return
14795 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14796 
    if self.catalog_item_id is not None:
14797 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14798 
      oprot.writeI64(self.catalog_item_id)
14799 
      oprot.writeFieldEnd()
14800 
    oprot.writeFieldStop()
14801 
    oprot.writeStructEnd()
14802 
 
14803 
  def validate(self):
14804 
    return
14805 
 
14806 
 
14807 
  def __repr__(self):
14808 
    L = ['%s=%r' % (key, value)
14809 
      for key, value in self.__dict__.iteritems()]
14810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14811 
 
14812 
  def __eq__(self, other):
14813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14814 
 
14815 
  def __ne__(self, other):
14816 
    return not (self == other)
14817 
 
14818 
class isValidCatalogItemId_result:
14819 
  """
14820 
  Attributes:
14821 
   - success
14822 
  """
14823 
 
14824 
  thrift_spec = (
14825 
    (0, TType.BOOL, 'success', None, None, ), # 0
14826 
  )
14827 
 
14828 
  def __init__(self, success=None,):
14829 
    self.success = success
14830 
 
14831 
  def read(self, iprot):
14832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14834 
      return
14835 
    iprot.readStructBegin()
14836 
    while True:
14837 
      (fname, ftype, fid) = iprot.readFieldBegin()
14838 
      if ftype == TType.STOP:
14839 
        break
14840 
      if fid == 0:
14841 
        if ftype == TType.BOOL:
14842 
          self.success = iprot.readBool();
14843 
        else:
14844 
          iprot.skip(ftype)
14845 
      else:
14846 
        iprot.skip(ftype)
14847 
      iprot.readFieldEnd()
14848 
    iprot.readStructEnd()
14849 
 
14850 
  def write(self, oprot):
14851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14853 
      return
14854 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14855 
    if self.success is not None:
14856 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14857 
      oprot.writeBool(self.success)
14858 
      oprot.writeFieldEnd()
14859 
    oprot.writeFieldStop()
14860 
    oprot.writeStructEnd()
14861 
 
14862 
  def validate(self):
14863 
    return
14864 
 
14865 
 
14866 
  def __repr__(self):
14867 
    L = ['%s=%r' % (key, value)
14868 
      for key, value in self.__dict__.iteritems()]
14869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14870 
 
14871 
  def __eq__(self, other):
14872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14873 
 
14874 
  def __ne__(self, other):
14875 
    return not (self == other)
6039 amit.gupta 14876 
 
14877 
class getVatPercentageForItem_args:
14878 
  """
14879 
  Attributes:
14880 
   - itemId
7330 amit.gupta 14881 
   - stateId
6039 amit.gupta 14882 
   - price
14883 
  """
14884 
 
14885 
  thrift_spec = (
14886 
    None, # 0
14887 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 14888 
    (2, TType.I64, 'stateId', None, None, ), # 2
14889 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 14890 
  )
14891 
 
7330 amit.gupta 14892 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 14893 
    self.itemId = itemId
7330 amit.gupta 14894 
    self.stateId = stateId
6039 amit.gupta 14895 
    self.price = price
14896 
 
14897 
  def read(self, iprot):
14898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14900 
      return
14901 
    iprot.readStructBegin()
14902 
    while True:
14903 
      (fname, ftype, fid) = iprot.readFieldBegin()
14904 
      if ftype == TType.STOP:
14905 
        break
14906 
      if fid == 1:
14907 
        if ftype == TType.I64:
14908 
          self.itemId = iprot.readI64();
14909 
        else:
14910 
          iprot.skip(ftype)
14911 
      elif fid == 2:
7330 amit.gupta 14912 
        if ftype == TType.I64:
14913 
          self.stateId = iprot.readI64();
14914 
        else:
14915 
          iprot.skip(ftype)
14916 
      elif fid == 3:
6039 amit.gupta 14917 
        if ftype == TType.DOUBLE:
14918 
          self.price = iprot.readDouble();
14919 
        else:
14920 
          iprot.skip(ftype)
14921 
      else:
14922 
        iprot.skip(ftype)
14923 
      iprot.readFieldEnd()
14924 
    iprot.readStructEnd()
14925 
 
14926 
  def write(self, oprot):
14927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14929 
      return
14930 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14931 
    if self.itemId is not None:
14932 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14933 
      oprot.writeI64(self.itemId)
14934 
      oprot.writeFieldEnd()
7330 amit.gupta 14935 
    if self.stateId is not None:
14936 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
14937 
      oprot.writeI64(self.stateId)
14938 
      oprot.writeFieldEnd()
6039 amit.gupta 14939 
    if self.price is not None:
7330 amit.gupta 14940 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 14941 
      oprot.writeDouble(self.price)
14942 
      oprot.writeFieldEnd()
14943 
    oprot.writeFieldStop()
14944 
    oprot.writeStructEnd()
14945 
 
14946 
  def validate(self):
14947 
    return
14948 
 
14949 
 
14950 
  def __repr__(self):
14951 
    L = ['%s=%r' % (key, value)
14952 
      for key, value in self.__dict__.iteritems()]
14953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14954 
 
14955 
  def __eq__(self, other):
14956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14957 
 
14958 
  def __ne__(self, other):
14959 
    return not (self == other)
14960 
 
14961 
class getVatPercentageForItem_result:
14962 
  """
14963 
  Attributes:
14964 
   - success
14965 
  """
14966 
 
14967 
  thrift_spec = (
14968 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14969 
  )
14970 
 
14971 
  def __init__(self, success=None,):
14972 
    self.success = success
14973 
 
14974 
  def read(self, iprot):
14975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14977 
      return
14978 
    iprot.readStructBegin()
14979 
    while True:
14980 
      (fname, ftype, fid) = iprot.readFieldBegin()
14981 
      if ftype == TType.STOP:
14982 
        break
14983 
      if fid == 0:
14984 
        if ftype == TType.DOUBLE:
14985 
          self.success = iprot.readDouble();
14986 
        else:
14987 
          iprot.skip(ftype)
14988 
      else:
14989 
        iprot.skip(ftype)
14990 
      iprot.readFieldEnd()
14991 
    iprot.readStructEnd()
14992 
 
14993 
  def write(self, oprot):
14994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14996 
      return
14997 
    oprot.writeStructBegin('getVatPercentageForItem_result')
14998 
    if self.success is not None:
14999 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15000 
      oprot.writeDouble(self.success)
15001 
      oprot.writeFieldEnd()
15002 
    oprot.writeFieldStop()
15003 
    oprot.writeStructEnd()
15004 
 
15005 
  def validate(self):
15006 
    return
15007 
 
15008 
 
15009 
  def __repr__(self):
15010 
    L = ['%s=%r' % (key, value)
15011 
      for key, value in self.__dict__.iteritems()]
15012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15013 
 
15014 
  def __eq__(self, other):
15015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15016 
 
15017 
  def __ne__(self, other):
15018 
    return not (self == other)
15019 
 
15020 
class getVatAmountForItem_args:
15021 
  """
15022 
  Attributes:
15023 
   - itemId
15024 
   - price
15025 
  """
15026 
 
15027 
  thrift_spec = (
15028 
    None, # 0
15029 
    (1, TType.I64, 'itemId', None, None, ), # 1
15030 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15031 
  )
15032 
 
15033 
  def __init__(self, itemId=None, price=None,):
15034 
    self.itemId = itemId
15035 
    self.price = price
15036 
 
15037 
  def read(self, iprot):
15038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15040 
      return
15041 
    iprot.readStructBegin()
15042 
    while True:
15043 
      (fname, ftype, fid) = iprot.readFieldBegin()
15044 
      if ftype == TType.STOP:
15045 
        break
15046 
      if fid == 1:
15047 
        if ftype == TType.I64:
15048 
          self.itemId = iprot.readI64();
15049 
        else:
15050 
          iprot.skip(ftype)
15051 
      elif fid == 2:
15052 
        if ftype == TType.DOUBLE:
15053 
          self.price = iprot.readDouble();
15054 
        else:
15055 
          iprot.skip(ftype)
15056 
      else:
15057 
        iprot.skip(ftype)
15058 
      iprot.readFieldEnd()
15059 
    iprot.readStructEnd()
15060 
 
15061 
  def write(self, oprot):
15062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15064 
      return
15065 
    oprot.writeStructBegin('getVatAmountForItem_args')
15066 
    if self.itemId is not None:
15067 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15068 
      oprot.writeI64(self.itemId)
15069 
      oprot.writeFieldEnd()
15070 
    if self.price is not None:
15071 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15072 
      oprot.writeDouble(self.price)
15073 
      oprot.writeFieldEnd()
15074 
    oprot.writeFieldStop()
15075 
    oprot.writeStructEnd()
15076 
 
15077 
  def validate(self):
15078 
    return
15079 
 
15080 
 
15081 
  def __repr__(self):
15082 
    L = ['%s=%r' % (key, value)
15083 
      for key, value in self.__dict__.iteritems()]
15084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15085 
 
15086 
  def __eq__(self, other):
15087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15088 
 
15089 
  def __ne__(self, other):
15090 
    return not (self == other)
15091 
 
15092 
class getVatAmountForItem_result:
15093 
  """
15094 
  Attributes:
15095 
   - success
15096 
  """
15097 
 
15098 
  thrift_spec = (
15099 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15100 
  )
15101 
 
15102 
  def __init__(self, success=None,):
15103 
    self.success = success
15104 
 
15105 
  def read(self, iprot):
15106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15108 
      return
15109 
    iprot.readStructBegin()
15110 
    while True:
15111 
      (fname, ftype, fid) = iprot.readFieldBegin()
15112 
      if ftype == TType.STOP:
15113 
        break
15114 
      if fid == 0:
15115 
        if ftype == TType.DOUBLE:
15116 
          self.success = iprot.readDouble();
15117 
        else:
15118 
          iprot.skip(ftype)
15119 
      else:
15120 
        iprot.skip(ftype)
15121 
      iprot.readFieldEnd()
15122 
    iprot.readStructEnd()
15123 
 
15124 
  def write(self, oprot):
15125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15127 
      return
15128 
    oprot.writeStructBegin('getVatAmountForItem_result')
15129 
    if self.success is not None:
15130 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15131 
      oprot.writeDouble(self.success)
15132 
      oprot.writeFieldEnd()
15133 
    oprot.writeFieldStop()
15134 
    oprot.writeStructEnd()
15135 
 
15136 
  def validate(self):
15137 
    return
15138 
 
15139 
 
15140 
  def __repr__(self):
15141 
    L = ['%s=%r' % (key, value)
15142 
      for key, value in self.__dict__.iteritems()]
15143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15144 
 
15145 
  def __eq__(self, other):
15146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15147 
 
15148 
  def __ne__(self, other):
15149 
    return not (self == other)
6531 vikram.rag 15150 
 
15151 
class getAllIgnoredInventoryUpdateItemsList_args:
15152 
  """
15153 
  Attributes:
15154 
   - offset
15155 
   - limit
15156 
  """
15157 
 
15158 
  thrift_spec = (
15159 
    None, # 0
15160 
    (1, TType.I32, 'offset', None, None, ), # 1
15161 
    (2, TType.I32, 'limit', None, None, ), # 2
15162 
  )
15163 
 
15164 
  def __init__(self, offset=None, limit=None,):
15165 
    self.offset = offset
15166 
    self.limit = limit
15167 
 
15168 
  def read(self, iprot):
15169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15171 
      return
15172 
    iprot.readStructBegin()
15173 
    while True:
15174 
      (fname, ftype, fid) = iprot.readFieldBegin()
15175 
      if ftype == TType.STOP:
15176 
        break
15177 
      if fid == 1:
15178 
        if ftype == TType.I32:
15179 
          self.offset = iprot.readI32();
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      elif fid == 2:
15183 
        if ftype == TType.I32:
15184 
          self.limit = iprot.readI32();
15185 
        else:
15186 
          iprot.skip(ftype)
15187 
      else:
15188 
        iprot.skip(ftype)
15189 
      iprot.readFieldEnd()
15190 
    iprot.readStructEnd()
15191 
 
15192 
  def write(self, oprot):
15193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15195 
      return
15196 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15197 
    if self.offset is not None:
15198 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15199 
      oprot.writeI32(self.offset)
15200 
      oprot.writeFieldEnd()
15201 
    if self.limit is not None:
15202 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15203 
      oprot.writeI32(self.limit)
15204 
      oprot.writeFieldEnd()
15205 
    oprot.writeFieldStop()
15206 
    oprot.writeStructEnd()
15207 
 
15208 
  def validate(self):
15209 
    return
15210 
 
15211 
 
15212 
  def __repr__(self):
15213 
    L = ['%s=%r' % (key, value)
15214 
      for key, value in self.__dict__.iteritems()]
15215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15216 
 
15217 
  def __eq__(self, other):
15218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15219 
 
15220 
  def __ne__(self, other):
15221 
    return not (self == other)
15222 
 
15223 
class getAllIgnoredInventoryUpdateItemsList_result:
15224 
  """
15225 
  Attributes:
15226 
   - success
15227 
  """
15228 
 
15229 
  thrift_spec = (
15230 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15231 
  )
15232 
 
15233 
  def __init__(self, success=None,):
15234 
    self.success = success
15235 
 
15236 
  def read(self, iprot):
15237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15239 
      return
15240 
    iprot.readStructBegin()
15241 
    while True:
15242 
      (fname, ftype, fid) = iprot.readFieldBegin()
15243 
      if ftype == TType.STOP:
15244 
        break
15245 
      if fid == 0:
15246 
        if ftype == TType.LIST:
15247 
          self.success = []
7256 rajveer 15248 
          (_etype280, _size277) = iprot.readListBegin()
15249 
          for _i281 in xrange(_size277):
15250 
            _elem282 = Item()
15251 
            _elem282.read(iprot)
15252 
            self.success.append(_elem282)
6531 vikram.rag 15253 
          iprot.readListEnd()
15254 
        else:
15255 
          iprot.skip(ftype)
15256 
      else:
15257 
        iprot.skip(ftype)
15258 
      iprot.readFieldEnd()
15259 
    iprot.readStructEnd()
15260 
 
15261 
  def write(self, oprot):
15262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15264 
      return
15265 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15266 
    if self.success is not None:
15267 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15268 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15269 
      for iter283 in self.success:
15270 
        iter283.write(oprot)
6531 vikram.rag 15271 
      oprot.writeListEnd()
15272 
      oprot.writeFieldEnd()
15273 
    oprot.writeFieldStop()
15274 
    oprot.writeStructEnd()
15275 
 
15276 
  def validate(self):
15277 
    return
15278 
 
15279 
 
15280 
  def __repr__(self):
15281 
    L = ['%s=%r' % (key, value)
15282 
      for key, value in self.__dict__.iteritems()]
15283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15284 
 
15285 
  def __eq__(self, other):
15286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15287 
 
15288 
  def __ne__(self, other):
15289 
    return not (self == other)
6805 anupam.sin 15290 
 
6821 amar.kumar 15291 
class getAllAliveItems_args:
15292 
 
15293 
  thrift_spec = (
15294 
  )
15295 
 
15296 
  def read(self, iprot):
15297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15299 
      return
15300 
    iprot.readStructBegin()
15301 
    while True:
15302 
      (fname, ftype, fid) = iprot.readFieldBegin()
15303 
      if ftype == TType.STOP:
15304 
        break
15305 
      else:
15306 
        iprot.skip(ftype)
15307 
      iprot.readFieldEnd()
15308 
    iprot.readStructEnd()
15309 
 
15310 
  def write(self, oprot):
15311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15313 
      return
15314 
    oprot.writeStructBegin('getAllAliveItems_args')
15315 
    oprot.writeFieldStop()
15316 
    oprot.writeStructEnd()
15317 
 
15318 
  def validate(self):
15319 
    return
15320 
 
15321 
 
15322 
  def __repr__(self):
15323 
    L = ['%s=%r' % (key, value)
15324 
      for key, value in self.__dict__.iteritems()]
15325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15326 
 
15327 
  def __eq__(self, other):
15328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15329 
 
15330 
  def __ne__(self, other):
15331 
    return not (self == other)
15332 
 
15333 
class getAllAliveItems_result:
15334 
  """
15335 
  Attributes:
15336 
   - success
15337 
  """
15338 
 
15339 
  thrift_spec = (
15340 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15341 
  )
15342 
 
15343 
  def __init__(self, success=None,):
15344 
    self.success = success
15345 
 
15346 
  def read(self, iprot):
15347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15349 
      return
15350 
    iprot.readStructBegin()
15351 
    while True:
15352 
      (fname, ftype, fid) = iprot.readFieldBegin()
15353 
      if ftype == TType.STOP:
15354 
        break
15355 
      if fid == 0:
15356 
        if ftype == TType.LIST:
15357 
          self.success = []
7256 rajveer 15358 
          (_etype287, _size284) = iprot.readListBegin()
15359 
          for _i288 in xrange(_size284):
15360 
            _elem289 = Item()
15361 
            _elem289.read(iprot)
15362 
            self.success.append(_elem289)
6821 amar.kumar 15363 
          iprot.readListEnd()
15364 
        else:
15365 
          iprot.skip(ftype)
15366 
      else:
15367 
        iprot.skip(ftype)
15368 
      iprot.readFieldEnd()
15369 
    iprot.readStructEnd()
15370 
 
15371 
  def write(self, oprot):
15372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15374 
      return
15375 
    oprot.writeStructBegin('getAllAliveItems_result')
15376 
    if self.success is not None:
15377 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15378 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15379 
      for iter290 in self.success:
15380 
        iter290.write(oprot)
6821 amar.kumar 15381 
      oprot.writeListEnd()
15382 
      oprot.writeFieldEnd()
15383 
    oprot.writeFieldStop()
15384 
    oprot.writeStructEnd()
15385 
 
15386 
  def validate(self):
15387 
    return
15388 
 
15389 
 
15390 
  def __repr__(self):
15391 
    L = ['%s=%r' % (key, value)
15392 
      for key, value in self.__dict__.iteritems()]
15393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15394 
 
15395 
  def __eq__(self, other):
15396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15397 
 
15398 
  def __ne__(self, other):
15399 
    return not (self == other)
15400 
 
6805 anupam.sin 15401 
class getInsuranceAmount_args:
15402 
  """
15403 
  Attributes:
15404 
   - itemId
6921 anupam.sin 15405 
   - price
6805 anupam.sin 15406 
   - insurerId
15407 
   - quantity
15408 
  """
15409 
 
15410 
  thrift_spec = (
15411 
    None, # 0
15412 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15413 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15414 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15415 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15416 
  )
15417 
 
6921 anupam.sin 15418 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15419 
    self.itemId = itemId
6921 anupam.sin 15420 
    self.price = price
6805 anupam.sin 15421 
    self.insurerId = insurerId
15422 
    self.quantity = quantity
15423 
 
15424 
  def read(self, iprot):
15425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15427 
      return
15428 
    iprot.readStructBegin()
15429 
    while True:
15430 
      (fname, ftype, fid) = iprot.readFieldBegin()
15431 
      if ftype == TType.STOP:
15432 
        break
15433 
      if fid == 1:
15434 
        if ftype == TType.I64:
15435 
          self.itemId = iprot.readI64();
15436 
        else:
15437 
          iprot.skip(ftype)
15438 
      elif fid == 2:
6921 anupam.sin 15439 
        if ftype == TType.DOUBLE:
15440 
          self.price = iprot.readDouble();
15441 
        else:
15442 
          iprot.skip(ftype)
15443 
      elif fid == 3:
6805 anupam.sin 15444 
        if ftype == TType.I64:
15445 
          self.insurerId = iprot.readI64();
15446 
        else:
15447 
          iprot.skip(ftype)
6921 anupam.sin 15448 
      elif fid == 4:
6805 anupam.sin 15449 
        if ftype == TType.I64:
15450 
          self.quantity = iprot.readI64();
15451 
        else:
15452 
          iprot.skip(ftype)
15453 
      else:
15454 
        iprot.skip(ftype)
15455 
      iprot.readFieldEnd()
15456 
    iprot.readStructEnd()
15457 
 
15458 
  def write(self, oprot):
15459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15461 
      return
15462 
    oprot.writeStructBegin('getInsuranceAmount_args')
15463 
    if self.itemId is not None:
15464 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15465 
      oprot.writeI64(self.itemId)
15466 
      oprot.writeFieldEnd()
6921 anupam.sin 15467 
    if self.price is not None:
15468 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15469 
      oprot.writeDouble(self.price)
15470 
      oprot.writeFieldEnd()
6805 anupam.sin 15471 
    if self.insurerId is not None:
6921 anupam.sin 15472 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15473 
      oprot.writeI64(self.insurerId)
15474 
      oprot.writeFieldEnd()
15475 
    if self.quantity is not None:
6921 anupam.sin 15476 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15477 
      oprot.writeI64(self.quantity)
15478 
      oprot.writeFieldEnd()
15479 
    oprot.writeFieldStop()
15480 
    oprot.writeStructEnd()
15481 
 
15482 
  def validate(self):
15483 
    return
15484 
 
15485 
 
15486 
  def __repr__(self):
15487 
    L = ['%s=%r' % (key, value)
15488 
      for key, value in self.__dict__.iteritems()]
15489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15490 
 
15491 
  def __eq__(self, other):
15492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15493 
 
15494 
  def __ne__(self, other):
15495 
    return not (self == other)
15496 
 
15497 
class getInsuranceAmount_result:
15498 
  """
15499 
  Attributes:
15500 
   - success
15501 
  """
15502 
 
15503 
  thrift_spec = (
15504 
    (0, TType.I64, 'success', None, None, ), # 0
15505 
  )
15506 
 
15507 
  def __init__(self, success=None,):
15508 
    self.success = success
15509 
 
15510 
  def read(self, iprot):
15511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15513 
      return
15514 
    iprot.readStructBegin()
15515 
    while True:
15516 
      (fname, ftype, fid) = iprot.readFieldBegin()
15517 
      if ftype == TType.STOP:
15518 
        break
15519 
      if fid == 0:
15520 
        if ftype == TType.I64:
15521 
          self.success = iprot.readI64();
15522 
        else:
15523 
          iprot.skip(ftype)
15524 
      else:
15525 
        iprot.skip(ftype)
15526 
      iprot.readFieldEnd()
15527 
    iprot.readStructEnd()
15528 
 
15529 
  def write(self, oprot):
15530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15532 
      return
15533 
    oprot.writeStructBegin('getInsuranceAmount_result')
15534 
    if self.success is not None:
15535 
      oprot.writeFieldBegin('success', TType.I64, 0)
15536 
      oprot.writeI64(self.success)
15537 
      oprot.writeFieldEnd()
15538 
    oprot.writeFieldStop()
15539 
    oprot.writeStructEnd()
15540 
 
15541 
  def validate(self):
15542 
    return
15543 
 
15544 
 
15545 
  def __repr__(self):
15546 
    L = ['%s=%r' % (key, value)
15547 
      for key, value in self.__dict__.iteritems()]
15548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15549 
 
15550 
  def __eq__(self, other):
15551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15552 
 
15553 
  def __ne__(self, other):
15554 
    return not (self == other)
15555 
 
15556 
class getInsurer_args:
15557 
  """
15558 
  Attributes:
15559 
   - insurerId
15560 
  """
15561 
 
15562 
  thrift_spec = (
15563 
    None, # 0
15564 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15565 
  )
15566 
 
15567 
  def __init__(self, insurerId=None,):
15568 
    self.insurerId = insurerId
15569 
 
15570 
  def read(self, iprot):
15571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15573 
      return
15574 
    iprot.readStructBegin()
15575 
    while True:
15576 
      (fname, ftype, fid) = iprot.readFieldBegin()
15577 
      if ftype == TType.STOP:
15578 
        break
15579 
      if fid == 1:
15580 
        if ftype == TType.I64:
15581 
          self.insurerId = iprot.readI64();
15582 
        else:
15583 
          iprot.skip(ftype)
15584 
      else:
15585 
        iprot.skip(ftype)
15586 
      iprot.readFieldEnd()
15587 
    iprot.readStructEnd()
15588 
 
15589 
  def write(self, oprot):
15590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15592 
      return
15593 
    oprot.writeStructBegin('getInsurer_args')
15594 
    if self.insurerId is not None:
15595 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15596 
      oprot.writeI64(self.insurerId)
15597 
      oprot.writeFieldEnd()
15598 
    oprot.writeFieldStop()
15599 
    oprot.writeStructEnd()
15600 
 
15601 
  def validate(self):
15602 
    return
15603 
 
15604 
 
15605 
  def __repr__(self):
15606 
    L = ['%s=%r' % (key, value)
15607 
      for key, value in self.__dict__.iteritems()]
15608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15609 
 
15610 
  def __eq__(self, other):
15611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15612 
 
15613 
  def __ne__(self, other):
15614 
    return not (self == other)
15615 
 
15616 
class getInsurer_result:
15617 
  """
15618 
  Attributes:
15619 
   - success
15620 
  """
15621 
 
15622 
  thrift_spec = (
15623 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15624 
  )
15625 
 
15626 
  def __init__(self, success=None,):
15627 
    self.success = success
15628 
 
15629 
  def read(self, iprot):
15630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15632 
      return
15633 
    iprot.readStructBegin()
15634 
    while True:
15635 
      (fname, ftype, fid) = iprot.readFieldBegin()
15636 
      if ftype == TType.STOP:
15637 
        break
15638 
      if fid == 0:
15639 
        if ftype == TType.STRUCT:
15640 
          self.success = Insurer()
15641 
          self.success.read(iprot)
15642 
        else:
15643 
          iprot.skip(ftype)
15644 
      else:
15645 
        iprot.skip(ftype)
15646 
      iprot.readFieldEnd()
15647 
    iprot.readStructEnd()
15648 
 
15649 
  def write(self, oprot):
15650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15652 
      return
15653 
    oprot.writeStructBegin('getInsurer_result')
15654 
    if self.success is not None:
15655 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15656 
      self.success.write(oprot)
15657 
      oprot.writeFieldEnd()
15658 
    oprot.writeFieldStop()
15659 
    oprot.writeStructEnd()
15660 
 
15661 
  def validate(self):
15662 
    return
15663 
 
15664 
 
15665 
  def __repr__(self):
15666 
    L = ['%s=%r' % (key, value)
15667 
      for key, value in self.__dict__.iteritems()]
15668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15669 
 
15670 
  def __eq__(self, other):
15671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15672 
 
15673 
  def __ne__(self, other):
15674 
    return not (self == other)
6838 vikram.rag 15675 
 
15676 
class getAllInsurers_args:
15677 
 
15678 
  thrift_spec = (
15679 
  )
15680 
 
15681 
  def read(self, iprot):
15682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15684 
      return
15685 
    iprot.readStructBegin()
15686 
    while True:
15687 
      (fname, ftype, fid) = iprot.readFieldBegin()
15688 
      if ftype == TType.STOP:
15689 
        break
15690 
      else:
15691 
        iprot.skip(ftype)
15692 
      iprot.readFieldEnd()
15693 
    iprot.readStructEnd()
15694 
 
15695 
  def write(self, oprot):
15696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15698 
      return
15699 
    oprot.writeStructBegin('getAllInsurers_args')
15700 
    oprot.writeFieldStop()
15701 
    oprot.writeStructEnd()
15702 
 
15703 
  def validate(self):
15704 
    return
15705 
 
15706 
 
15707 
  def __repr__(self):
15708 
    L = ['%s=%r' % (key, value)
15709 
      for key, value in self.__dict__.iteritems()]
15710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15711 
 
15712 
  def __eq__(self, other):
15713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15714 
 
15715 
  def __ne__(self, other):
15716 
    return not (self == other)
15717 
 
15718 
class getAllInsurers_result:
15719 
  """
15720 
  Attributes:
15721 
   - success
15722 
  """
15723 
 
15724 
  thrift_spec = (
15725 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15726 
  )
15727 
 
15728 
  def __init__(self, success=None,):
15729 
    self.success = success
15730 
 
15731 
  def read(self, iprot):
15732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15734 
      return
15735 
    iprot.readStructBegin()
15736 
    while True:
15737 
      (fname, ftype, fid) = iprot.readFieldBegin()
15738 
      if ftype == TType.STOP:
15739 
        break
15740 
      if fid == 0:
15741 
        if ftype == TType.LIST:
15742 
          self.success = []
7256 rajveer 15743 
          (_etype294, _size291) = iprot.readListBegin()
15744 
          for _i295 in xrange(_size291):
15745 
            _elem296 = Insurer()
15746 
            _elem296.read(iprot)
15747 
            self.success.append(_elem296)
6838 vikram.rag 15748 
          iprot.readListEnd()
15749 
        else:
15750 
          iprot.skip(ftype)
15751 
      else:
15752 
        iprot.skip(ftype)
15753 
      iprot.readFieldEnd()
15754 
    iprot.readStructEnd()
15755 
 
15756 
  def write(self, oprot):
15757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15759 
      return
15760 
    oprot.writeStructBegin('getAllInsurers_result')
15761 
    if self.success is not None:
15762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15764 
      for iter297 in self.success:
15765 
        iter297.write(oprot)
6838 vikram.rag 15766 
      oprot.writeListEnd()
15767 
      oprot.writeFieldEnd()
15768 
    oprot.writeFieldStop()
15769 
    oprot.writeStructEnd()
15770 
 
15771 
  def validate(self):
15772 
    return
15773 
 
15774 
 
15775 
  def __repr__(self):
15776 
    L = ['%s=%r' % (key, value)
15777 
      for key, value in self.__dict__.iteritems()]
15778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15779 
 
15780 
  def __eq__(self, other):
15781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15782 
 
15783 
  def __ne__(self, other):
15784 
    return not (self == other)
6962 rajveer 15785 
 
15786 
class updateInsuranceDeclaredAmount_args:
15787 
  """
15788 
  Attributes:
15789 
   - insurerId
15790 
   - amount
15791 
  """
15792 
 
15793 
  thrift_spec = (
15794 
    None, # 0
15795 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15796 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15797 
  )
15798 
 
15799 
  def __init__(self, insurerId=None, amount=None,):
15800 
    self.insurerId = insurerId
15801 
    self.amount = amount
15802 
 
15803 
  def read(self, iprot):
15804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15806 
      return
15807 
    iprot.readStructBegin()
15808 
    while True:
15809 
      (fname, ftype, fid) = iprot.readFieldBegin()
15810 
      if ftype == TType.STOP:
15811 
        break
15812 
      if fid == 1:
15813 
        if ftype == TType.I64:
15814 
          self.insurerId = iprot.readI64();
15815 
        else:
15816 
          iprot.skip(ftype)
15817 
      elif fid == 2:
15818 
        if ftype == TType.DOUBLE:
15819 
          self.amount = iprot.readDouble();
15820 
        else:
15821 
          iprot.skip(ftype)
15822 
      else:
15823 
        iprot.skip(ftype)
15824 
      iprot.readFieldEnd()
15825 
    iprot.readStructEnd()
15826 
 
15827 
  def write(self, oprot):
15828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15830 
      return
15831 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15832 
    if self.insurerId is not None:
15833 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15834 
      oprot.writeI64(self.insurerId)
15835 
      oprot.writeFieldEnd()
15836 
    if self.amount is not None:
15837 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15838 
      oprot.writeDouble(self.amount)
15839 
      oprot.writeFieldEnd()
15840 
    oprot.writeFieldStop()
15841 
    oprot.writeStructEnd()
15842 
 
15843 
  def validate(self):
15844 
    return
15845 
 
15846 
 
15847 
  def __repr__(self):
15848 
    L = ['%s=%r' % (key, value)
15849 
      for key, value in self.__dict__.iteritems()]
15850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15851 
 
15852 
  def __eq__(self, other):
15853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15854 
 
15855 
  def __ne__(self, other):
15856 
    return not (self == other)
15857 
 
15858 
class updateInsuranceDeclaredAmount_result:
15859 
 
15860 
  thrift_spec = (
15861 
  )
15862 
 
15863 
  def read(self, iprot):
15864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15866 
      return
15867 
    iprot.readStructBegin()
15868 
    while True:
15869 
      (fname, ftype, fid) = iprot.readFieldBegin()
15870 
      if ftype == TType.STOP:
15871 
        break
15872 
      else:
15873 
        iprot.skip(ftype)
15874 
      iprot.readFieldEnd()
15875 
    iprot.readStructEnd()
15876 
 
15877 
  def write(self, oprot):
15878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15880 
      return
15881 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15882 
    oprot.writeFieldStop()
15883 
    oprot.writeStructEnd()
15884 
 
15885 
  def validate(self):
15886 
    return
15887 
 
15888 
 
15889 
  def __repr__(self):
15890 
    L = ['%s=%r' % (key, value)
15891 
      for key, value in self.__dict__.iteritems()]
15892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15893 
 
15894 
  def __eq__(self, other):
15895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15896 
 
15897 
  def __ne__(self, other):
15898 
    return not (self == other)
7190 amar.kumar 15899 
 
15900 
class getFreebieForItem_args:
15901 
  """
15902 
  Attributes:
15903 
   - itemId
15904 
  """
15905 
 
15906 
  thrift_spec = (
15907 
    None, # 0
15908 
    (1, TType.I64, 'itemId', None, None, ), # 1
15909 
  )
15910 
 
15911 
  def __init__(self, itemId=None,):
15912 
    self.itemId = itemId
15913 
 
15914 
  def read(self, iprot):
15915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15917 
      return
15918 
    iprot.readStructBegin()
15919 
    while True:
15920 
      (fname, ftype, fid) = iprot.readFieldBegin()
15921 
      if ftype == TType.STOP:
15922 
        break
15923 
      if fid == 1:
15924 
        if ftype == TType.I64:
15925 
          self.itemId = iprot.readI64();
15926 
        else:
15927 
          iprot.skip(ftype)
15928 
      else:
15929 
        iprot.skip(ftype)
15930 
      iprot.readFieldEnd()
15931 
    iprot.readStructEnd()
15932 
 
15933 
  def write(self, oprot):
15934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15936 
      return
15937 
    oprot.writeStructBegin('getFreebieForItem_args')
15938 
    if self.itemId is not None:
15939 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15940 
      oprot.writeI64(self.itemId)
15941 
      oprot.writeFieldEnd()
15942 
    oprot.writeFieldStop()
15943 
    oprot.writeStructEnd()
15944 
 
15945 
  def validate(self):
15946 
    return
15947 
 
15948 
 
15949 
  def __repr__(self):
15950 
    L = ['%s=%r' % (key, value)
15951 
      for key, value in self.__dict__.iteritems()]
15952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15953 
 
15954 
  def __eq__(self, other):
15955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15956 
 
15957 
  def __ne__(self, other):
15958 
    return not (self == other)
15959 
 
15960 
class getFreebieForItem_result:
15961 
  """
15962 
  Attributes:
15963 
   - success
15964 
  """
15965 
 
15966 
  thrift_spec = (
15967 
    (0, TType.I64, 'success', None, None, ), # 0
15968 
  )
15969 
 
15970 
  def __init__(self, success=None,):
15971 
    self.success = success
15972 
 
15973 
  def read(self, iprot):
15974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15976 
      return
15977 
    iprot.readStructBegin()
15978 
    while True:
15979 
      (fname, ftype, fid) = iprot.readFieldBegin()
15980 
      if ftype == TType.STOP:
15981 
        break
15982 
      if fid == 0:
15983 
        if ftype == TType.I64:
15984 
          self.success = iprot.readI64();
15985 
        else:
15986 
          iprot.skip(ftype)
15987 
      else:
15988 
        iprot.skip(ftype)
15989 
      iprot.readFieldEnd()
15990 
    iprot.readStructEnd()
15991 
 
15992 
  def write(self, oprot):
15993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15995 
      return
15996 
    oprot.writeStructBegin('getFreebieForItem_result')
15997 
    if self.success is not None:
15998 
      oprot.writeFieldBegin('success', TType.I64, 0)
15999 
      oprot.writeI64(self.success)
16000 
      oprot.writeFieldEnd()
16001 
    oprot.writeFieldStop()
16002 
    oprot.writeStructEnd()
16003 
 
16004 
  def validate(self):
16005 
    return
16006 
 
16007 
 
16008 
  def __repr__(self):
16009 
    L = ['%s=%r' % (key, value)
16010 
      for key, value in self.__dict__.iteritems()]
16011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16012 
 
16013 
  def __eq__(self, other):
16014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16015 
 
16016 
  def __ne__(self, other):
16017 
    return not (self == other)
16018 
 
16019 
class addOrUpdateFreebieForItem_args:
16020 
  """
16021 
  Attributes:
16022 
   - freebieItem
16023 
  """
16024 
 
16025 
  thrift_spec = (
16026 
    None, # 0
16027 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16028 
  )
16029 
 
16030 
  def __init__(self, freebieItem=None,):
16031 
    self.freebieItem = freebieItem
16032 
 
16033 
  def read(self, iprot):
16034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16036 
      return
16037 
    iprot.readStructBegin()
16038 
    while True:
16039 
      (fname, ftype, fid) = iprot.readFieldBegin()
16040 
      if ftype == TType.STOP:
16041 
        break
16042 
      if fid == 1:
16043 
        if ftype == TType.STRUCT:
16044 
          self.freebieItem = FreebieItem()
16045 
          self.freebieItem.read(iprot)
16046 
        else:
16047 
          iprot.skip(ftype)
16048 
      else:
16049 
        iprot.skip(ftype)
16050 
      iprot.readFieldEnd()
16051 
    iprot.readStructEnd()
16052 
 
16053 
  def write(self, oprot):
16054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16056 
      return
16057 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16058 
    if self.freebieItem is not None:
16059 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16060 
      self.freebieItem.write(oprot)
16061 
      oprot.writeFieldEnd()
16062 
    oprot.writeFieldStop()
16063 
    oprot.writeStructEnd()
16064 
 
16065 
  def validate(self):
16066 
    return
16067 
 
16068 
 
16069 
  def __repr__(self):
16070 
    L = ['%s=%r' % (key, value)
16071 
      for key, value in self.__dict__.iteritems()]
16072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16073 
 
16074 
  def __eq__(self, other):
16075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16076 
 
16077 
  def __ne__(self, other):
16078 
    return not (self == other)
16079 
 
16080 
class addOrUpdateFreebieForItem_result:
16081 
 
16082 
  thrift_spec = (
16083 
  )
16084 
 
16085 
  def read(self, iprot):
16086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16088 
      return
16089 
    iprot.readStructBegin()
16090 
    while True:
16091 
      (fname, ftype, fid) = iprot.readFieldBegin()
16092 
      if ftype == TType.STOP:
16093 
        break
16094 
      else:
16095 
        iprot.skip(ftype)
16096 
      iprot.readFieldEnd()
16097 
    iprot.readStructEnd()
16098 
 
16099 
  def write(self, oprot):
16100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16102 
      return
16103 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16104 
    oprot.writeFieldStop()
16105 
    oprot.writeStructEnd()
16106 
 
16107 
  def validate(self):
16108 
    return
16109 
 
16110 
 
16111 
  def __repr__(self):
16112 
    L = ['%s=%r' % (key, value)
16113 
      for key, value in self.__dict__.iteritems()]
16114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16115 
 
16116 
  def __eq__(self, other):
16117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16118 
 
16119 
  def __ne__(self, other):
16120 
    return not (self == other)
7256 rajveer 16121 
 
7272 amit.gupta 16122 
class addOrUpdateBrandInfo_args:
16123 
  """
16124 
  Attributes:
16125 
   - brandInfo
16126 
  """
16127 
 
16128 
  thrift_spec = (
16129 
    None, # 0
16130 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16131 
  )
16132 
 
16133 
  def __init__(self, brandInfo=None,):
16134 
    self.brandInfo = brandInfo
16135 
 
16136 
  def read(self, iprot):
16137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16139 
      return
16140 
    iprot.readStructBegin()
16141 
    while True:
16142 
      (fname, ftype, fid) = iprot.readFieldBegin()
16143 
      if ftype == TType.STOP:
16144 
        break
16145 
      if fid == 1:
16146 
        if ftype == TType.STRUCT:
16147 
          self.brandInfo = BrandInfo()
16148 
          self.brandInfo.read(iprot)
16149 
        else:
16150 
          iprot.skip(ftype)
16151 
      else:
16152 
        iprot.skip(ftype)
16153 
      iprot.readFieldEnd()
16154 
    iprot.readStructEnd()
16155 
 
16156 
  def write(self, oprot):
16157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16159 
      return
16160 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16161 
    if self.brandInfo is not None:
16162 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16163 
      self.brandInfo.write(oprot)
16164 
      oprot.writeFieldEnd()
16165 
    oprot.writeFieldStop()
16166 
    oprot.writeStructEnd()
16167 
 
16168 
  def validate(self):
16169 
    return
16170 
 
16171 
 
16172 
  def __repr__(self):
16173 
    L = ['%s=%r' % (key, value)
16174 
      for key, value in self.__dict__.iteritems()]
16175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16176 
 
16177 
  def __eq__(self, other):
16178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16179 
 
16180 
  def __ne__(self, other):
16181 
    return not (self == other)
16182 
 
16183 
class addOrUpdateBrandInfo_result:
16184 
 
16185 
  thrift_spec = (
16186 
  )
16187 
 
16188 
  def read(self, iprot):
16189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16191 
      return
16192 
    iprot.readStructBegin()
16193 
    while True:
16194 
      (fname, ftype, fid) = iprot.readFieldBegin()
16195 
      if ftype == TType.STOP:
16196 
        break
16197 
      else:
16198 
        iprot.skip(ftype)
16199 
      iprot.readFieldEnd()
16200 
    iprot.readStructEnd()
16201 
 
16202 
  def write(self, oprot):
16203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16205 
      return
16206 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16207 
    oprot.writeFieldStop()
16208 
    oprot.writeStructEnd()
16209 
 
16210 
  def validate(self):
16211 
    return
16212 
 
16213 
 
16214 
  def __repr__(self):
16215 
    L = ['%s=%r' % (key, value)
16216 
      for key, value in self.__dict__.iteritems()]
16217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16218 
 
16219 
  def __eq__(self, other):
16220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16221 
 
16222 
  def __ne__(self, other):
16223 
    return not (self == other)
16224 
 
16225 
class getBrandInfo_args:
16226 
 
16227 
  thrift_spec = (
16228 
  )
16229 
 
16230 
  def read(self, iprot):
16231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16233 
      return
16234 
    iprot.readStructBegin()
16235 
    while True:
16236 
      (fname, ftype, fid) = iprot.readFieldBegin()
16237 
      if ftype == TType.STOP:
16238 
        break
16239 
      else:
16240 
        iprot.skip(ftype)
16241 
      iprot.readFieldEnd()
16242 
    iprot.readStructEnd()
16243 
 
16244 
  def write(self, oprot):
16245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16247 
      return
16248 
    oprot.writeStructBegin('getBrandInfo_args')
16249 
    oprot.writeFieldStop()
16250 
    oprot.writeStructEnd()
16251 
 
16252 
  def validate(self):
16253 
    return
16254 
 
16255 
 
16256 
  def __repr__(self):
16257 
    L = ['%s=%r' % (key, value)
16258 
      for key, value in self.__dict__.iteritems()]
16259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16260 
 
16261 
  def __eq__(self, other):
16262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16263 
 
16264 
  def __ne__(self, other):
16265 
    return not (self == other)
16266 
 
16267 
class getBrandInfo_result:
16268 
  """
16269 
  Attributes:
16270 
   - success
16271 
  """
16272 
 
16273 
  thrift_spec = (
16274 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16275 
  )
16276 
 
16277 
  def __init__(self, success=None,):
16278 
    self.success = success
16279 
 
16280 
  def read(self, iprot):
16281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16283 
      return
16284 
    iprot.readStructBegin()
16285 
    while True:
16286 
      (fname, ftype, fid) = iprot.readFieldBegin()
16287 
      if ftype == TType.STOP:
16288 
        break
16289 
      if fid == 0:
16290 
        if ftype == TType.MAP:
16291 
          self.success = {}
16292 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16293 
          for _i302 in xrange(_size298):
16294 
            _key303 = iprot.readString();
16295 
            _val304 = BrandInfo()
16296 
            _val304.read(iprot)
16297 
            self.success[_key303] = _val304
16298 
          iprot.readMapEnd()
16299 
        else:
16300 
          iprot.skip(ftype)
16301 
      else:
16302 
        iprot.skip(ftype)
16303 
      iprot.readFieldEnd()
16304 
    iprot.readStructEnd()
16305 
 
16306 
  def write(self, oprot):
16307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16309 
      return
16310 
    oprot.writeStructBegin('getBrandInfo_result')
16311 
    if self.success is not None:
16312 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16313 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16314 
      for kiter305,viter306 in self.success.items():
16315 
        oprot.writeString(kiter305)
16316 
        viter306.write(oprot)
16317 
      oprot.writeMapEnd()
16318 
      oprot.writeFieldEnd()
16319 
    oprot.writeFieldStop()
16320 
    oprot.writeStructEnd()
16321 
 
16322 
  def validate(self):
16323 
    return
16324 
 
16325 
 
16326 
  def __repr__(self):
16327 
    L = ['%s=%r' % (key, value)
16328 
      for key, value in self.__dict__.iteritems()]
16329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16330 
 
16331 
  def __eq__(self, other):
16332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16333 
 
16334 
  def __ne__(self, other):
16335 
    return not (self == other)
16336 
 
7256 rajveer 16337 
class getStorePricing_args:
16338 
  """
16339 
  Attributes:
16340 
   - itemId
16341 
  """
16342 
 
16343 
  thrift_spec = (
16344 
    None, # 0
16345 
    (1, TType.I64, 'itemId', None, None, ), # 1
16346 
  )
16347 
 
16348 
  def __init__(self, itemId=None,):
16349 
    self.itemId = itemId
16350 
 
16351 
  def read(self, iprot):
16352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16354 
      return
16355 
    iprot.readStructBegin()
16356 
    while True:
16357 
      (fname, ftype, fid) = iprot.readFieldBegin()
16358 
      if ftype == TType.STOP:
16359 
        break
16360 
      if fid == 1:
16361 
        if ftype == TType.I64:
16362 
          self.itemId = iprot.readI64();
16363 
        else:
16364 
          iprot.skip(ftype)
16365 
      else:
16366 
        iprot.skip(ftype)
16367 
      iprot.readFieldEnd()
16368 
    iprot.readStructEnd()
16369 
 
16370 
  def write(self, oprot):
16371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16373 
      return
16374 
    oprot.writeStructBegin('getStorePricing_args')
16375 
    if self.itemId is not None:
16376 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16377 
      oprot.writeI64(self.itemId)
16378 
      oprot.writeFieldEnd()
16379 
    oprot.writeFieldStop()
16380 
    oprot.writeStructEnd()
16381 
 
16382 
  def validate(self):
16383 
    return
16384 
 
16385 
 
16386 
  def __repr__(self):
16387 
    L = ['%s=%r' % (key, value)
16388 
      for key, value in self.__dict__.iteritems()]
16389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16390 
 
16391 
  def __eq__(self, other):
16392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16393 
 
16394 
  def __ne__(self, other):
16395 
    return not (self == other)
16396 
 
16397 
class getStorePricing_result:
16398 
  """
16399 
  Attributes:
16400 
   - success
16401 
  """
16402 
 
16403 
  thrift_spec = (
16404 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16405 
  )
16406 
 
16407 
  def __init__(self, success=None,):
16408 
    self.success = success
16409 
 
16410 
  def read(self, iprot):
16411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16413 
      return
16414 
    iprot.readStructBegin()
16415 
    while True:
16416 
      (fname, ftype, fid) = iprot.readFieldBegin()
16417 
      if ftype == TType.STOP:
16418 
        break
16419 
      if fid == 0:
16420 
        if ftype == TType.STRUCT:
16421 
          self.success = StorePricing()
16422 
          self.success.read(iprot)
16423 
        else:
16424 
          iprot.skip(ftype)
16425 
      else:
16426 
        iprot.skip(ftype)
16427 
      iprot.readFieldEnd()
16428 
    iprot.readStructEnd()
16429 
 
16430 
  def write(self, oprot):
16431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16433 
      return
16434 
    oprot.writeStructBegin('getStorePricing_result')
16435 
    if self.success is not None:
16436 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16437 
      self.success.write(oprot)
16438 
      oprot.writeFieldEnd()
16439 
    oprot.writeFieldStop()
16440 
    oprot.writeStructEnd()
16441 
 
16442 
  def validate(self):
16443 
    return
16444 
 
16445 
 
16446 
  def __repr__(self):
16447 
    L = ['%s=%r' % (key, value)
16448 
      for key, value in self.__dict__.iteritems()]
16449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16450 
 
16451 
  def __eq__(self, other):
16452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16453 
 
16454 
  def __ne__(self, other):
16455 
    return not (self == other)
7265 rajveer 16456 
 
7306 rajveer 16457 
class getStorePricings_args:
16458 
  """
16459 
  Attributes:
16460 
   - itemIds
16461 
  """
16462 
 
16463 
  thrift_spec = (
16464 
    None, # 0
16465 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16466 
  )
16467 
 
16468 
  def __init__(self, itemIds=None,):
16469 
    self.itemIds = itemIds
16470 
 
16471 
  def read(self, iprot):
16472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16474 
      return
16475 
    iprot.readStructBegin()
16476 
    while True:
16477 
      (fname, ftype, fid) = iprot.readFieldBegin()
16478 
      if ftype == TType.STOP:
16479 
        break
16480 
      if fid == 1:
16481 
        if ftype == TType.LIST:
16482 
          self.itemIds = []
16483 
          (_etype310, _size307) = iprot.readListBegin()
16484 
          for _i311 in xrange(_size307):
16485 
            _elem312 = iprot.readI64();
16486 
            self.itemIds.append(_elem312)
16487 
          iprot.readListEnd()
16488 
        else:
16489 
          iprot.skip(ftype)
16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('getStorePricings_args')
16500 
    if self.itemIds is not None:
16501 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16502 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
16503 
      for iter313 in self.itemIds:
16504 
        oprot.writeI64(iter313)
16505 
      oprot.writeListEnd()
16506 
      oprot.writeFieldEnd()
16507 
    oprot.writeFieldStop()
16508 
    oprot.writeStructEnd()
16509 
 
16510 
  def validate(self):
16511 
    return
16512 
 
16513 
 
16514 
  def __repr__(self):
16515 
    L = ['%s=%r' % (key, value)
16516 
      for key, value in self.__dict__.iteritems()]
16517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16518 
 
16519 
  def __eq__(self, other):
16520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16521 
 
16522 
  def __ne__(self, other):
16523 
    return not (self == other)
16524 
 
16525 
class getStorePricings_result:
16526 
  """
16527 
  Attributes:
16528 
   - success
16529 
  """
16530 
 
16531 
  thrift_spec = (
16532 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16533 
  )
16534 
 
16535 
  def __init__(self, success=None,):
16536 
    self.success = success
16537 
 
16538 
  def read(self, iprot):
16539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16541 
      return
16542 
    iprot.readStructBegin()
16543 
    while True:
16544 
      (fname, ftype, fid) = iprot.readFieldBegin()
16545 
      if ftype == TType.STOP:
16546 
        break
16547 
      if fid == 0:
16548 
        if ftype == TType.LIST:
16549 
          self.success = []
16550 
          (_etype317, _size314) = iprot.readListBegin()
16551 
          for _i318 in xrange(_size314):
16552 
            _elem319 = StorePricing()
16553 
            _elem319.read(iprot)
16554 
            self.success.append(_elem319)
16555 
          iprot.readListEnd()
16556 
        else:
16557 
          iprot.skip(ftype)
16558 
      else:
16559 
        iprot.skip(ftype)
16560 
      iprot.readFieldEnd()
16561 
    iprot.readStructEnd()
16562 
 
16563 
  def write(self, oprot):
16564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16566 
      return
16567 
    oprot.writeStructBegin('getStorePricings_result')
16568 
    if self.success is not None:
16569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16571 
      for iter320 in self.success:
16572 
        iter320.write(oprot)
16573 
      oprot.writeListEnd()
16574 
      oprot.writeFieldEnd()
16575 
    oprot.writeFieldStop()
16576 
    oprot.writeStructEnd()
16577 
 
16578 
  def validate(self):
16579 
    return
16580 
 
16581 
 
16582 
  def __repr__(self):
16583 
    L = ['%s=%r' % (key, value)
16584 
      for key, value in self.__dict__.iteritems()]
16585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16586 
 
16587 
  def __eq__(self, other):
16588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16589 
 
16590 
  def __ne__(self, other):
16591 
    return not (self == other)
16592 
 
7265 rajveer 16593 
class updateStorePricing_args:
16594 
  """
16595 
  Attributes:
16596 
   - sp
16597 
  """
16598 
 
16599 
  thrift_spec = (
16600 
    None, # 0
16601 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
16602 
  )
16603 
 
16604 
  def __init__(self, sp=None,):
16605 
    self.sp = sp
16606 
 
16607 
  def read(self, iprot):
16608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16610 
      return
16611 
    iprot.readStructBegin()
16612 
    while True:
16613 
      (fname, ftype, fid) = iprot.readFieldBegin()
16614 
      if ftype == TType.STOP:
16615 
        break
16616 
      if fid == 1:
16617 
        if ftype == TType.STRUCT:
16618 
          self.sp = StorePricing()
16619 
          self.sp.read(iprot)
16620 
        else:
16621 
          iprot.skip(ftype)
16622 
      else:
16623 
        iprot.skip(ftype)
16624 
      iprot.readFieldEnd()
16625 
    iprot.readStructEnd()
16626 
 
16627 
  def write(self, oprot):
16628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16630 
      return
16631 
    oprot.writeStructBegin('updateStorePricing_args')
16632 
    if self.sp is not None:
16633 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16634 
      self.sp.write(oprot)
16635 
      oprot.writeFieldEnd()
16636 
    oprot.writeFieldStop()
16637 
    oprot.writeStructEnd()
16638 
 
16639 
  def validate(self):
16640 
    return
16641 
 
16642 
 
16643 
  def __repr__(self):
16644 
    L = ['%s=%r' % (key, value)
16645 
      for key, value in self.__dict__.iteritems()]
16646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16647 
 
16648 
  def __eq__(self, other):
16649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16650 
 
16651 
  def __ne__(self, other):
16652 
    return not (self == other)
16653 
 
16654 
class updateStorePricing_result:
16655 
 
16656 
  thrift_spec = (
16657 
  )
16658 
 
16659 
  def read(self, iprot):
16660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16662 
      return
16663 
    iprot.readStructBegin()
16664 
    while True:
16665 
      (fname, ftype, fid) = iprot.readFieldBegin()
16666 
      if ftype == TType.STOP:
16667 
        break
16668 
      else:
16669 
        iprot.skip(ftype)
16670 
      iprot.readFieldEnd()
16671 
    iprot.readStructEnd()
16672 
 
16673 
  def write(self, oprot):
16674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16676 
      return
16677 
    oprot.writeStructBegin('updateStorePricing_result')
16678 
    oprot.writeFieldStop()
16679 
    oprot.writeStructEnd()
16680 
 
16681 
  def validate(self):
16682 
    return
16683 
 
16684 
 
16685 
  def __repr__(self):
16686 
    L = ['%s=%r' % (key, value)
16687 
      for key, value in self.__dict__.iteritems()]
16688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16689 
 
16690 
  def __eq__(self, other):
16691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16692 
 
16693 
  def __ne__(self, other):
16694 
    return not (self == other)
7281 kshitij.so 16695 
 
16696 
class getAllAmazonListedItems_args:
16697 
 
16698 
  thrift_spec = (
16699 
  )
16700 
 
16701 
  def read(self, iprot):
16702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16704 
      return
16705 
    iprot.readStructBegin()
16706 
    while True:
16707 
      (fname, ftype, fid) = iprot.readFieldBegin()
16708 
      if ftype == TType.STOP:
16709 
        break
16710 
      else:
16711 
        iprot.skip(ftype)
16712 
      iprot.readFieldEnd()
16713 
    iprot.readStructEnd()
16714 
 
16715 
  def write(self, oprot):
16716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16718 
      return
16719 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16720 
    oprot.writeFieldStop()
16721 
    oprot.writeStructEnd()
16722 
 
16723 
  def validate(self):
16724 
    return
16725 
 
16726 
 
16727 
  def __repr__(self):
16728 
    L = ['%s=%r' % (key, value)
16729 
      for key, value in self.__dict__.iteritems()]
16730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16731 
 
16732 
  def __eq__(self, other):
16733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16734 
 
16735 
  def __ne__(self, other):
16736 
    return not (self == other)
16737 
 
16738 
class getAllAmazonListedItems_result:
16739 
  """
16740 
  Attributes:
16741 
   - success
16742 
  """
16743 
 
16744 
  thrift_spec = (
16745 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16746 
  )
16747 
 
16748 
  def __init__(self, success=None,):
16749 
    self.success = success
16750 
 
16751 
  def read(self, iprot):
16752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16754 
      return
16755 
    iprot.readStructBegin()
16756 
    while True:
16757 
      (fname, ftype, fid) = iprot.readFieldBegin()
16758 
      if ftype == TType.STOP:
16759 
        break
16760 
      if fid == 0:
16761 
        if ftype == TType.LIST:
16762 
          self.success = []
7306 rajveer 16763 
          (_etype324, _size321) = iprot.readListBegin()
16764 
          for _i325 in xrange(_size321):
16765 
            _elem326 = Amazonlisted()
16766 
            _elem326.read(iprot)
16767 
            self.success.append(_elem326)
7281 kshitij.so 16768 
          iprot.readListEnd()
16769 
        else:
16770 
          iprot.skip(ftype)
16771 
      else:
16772 
        iprot.skip(ftype)
16773 
      iprot.readFieldEnd()
16774 
    iprot.readStructEnd()
16775 
 
16776 
  def write(self, oprot):
16777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16779 
      return
16780 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16781 
    if self.success is not None:
16782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16783 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 16784 
      for iter327 in self.success:
16785 
        iter327.write(oprot)
7281 kshitij.so 16786 
      oprot.writeListEnd()
16787 
      oprot.writeFieldEnd()
16788 
    oprot.writeFieldStop()
16789 
    oprot.writeStructEnd()
16790 
 
16791 
  def validate(self):
16792 
    return
16793 
 
16794 
 
16795 
  def __repr__(self):
16796 
    L = ['%s=%r' % (key, value)
16797 
      for key, value in self.__dict__.iteritems()]
16798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16799 
 
16800 
  def __eq__(self, other):
16801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16802 
 
16803 
  def __ne__(self, other):
16804 
    return not (self == other)
16805 
 
16806 
class getAmazonItemDetails_args:
16807 
  """
16808 
  Attributes:
16809 
   - itemId
16810 
  """
16811 
 
16812 
  thrift_spec = (
16813 
    None, # 0
16814 
    (1, TType.I64, 'itemId', None, None, ), # 1
16815 
  )
16816 
 
16817 
  def __init__(self, itemId=None,):
16818 
    self.itemId = itemId
16819 
 
16820 
  def read(self, iprot):
16821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16823 
      return
16824 
    iprot.readStructBegin()
16825 
    while True:
16826 
      (fname, ftype, fid) = iprot.readFieldBegin()
16827 
      if ftype == TType.STOP:
16828 
        break
16829 
      if fid == 1:
16830 
        if ftype == TType.I64:
16831 
          self.itemId = iprot.readI64();
16832 
        else:
16833 
          iprot.skip(ftype)
16834 
      else:
16835 
        iprot.skip(ftype)
16836 
      iprot.readFieldEnd()
16837 
    iprot.readStructEnd()
16838 
 
16839 
  def write(self, oprot):
16840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16842 
      return
16843 
    oprot.writeStructBegin('getAmazonItemDetails_args')
16844 
    if self.itemId is not None:
16845 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16846 
      oprot.writeI64(self.itemId)
16847 
      oprot.writeFieldEnd()
16848 
    oprot.writeFieldStop()
16849 
    oprot.writeStructEnd()
16850 
 
16851 
  def validate(self):
16852 
    return
16853 
 
16854 
 
16855 
  def __repr__(self):
16856 
    L = ['%s=%r' % (key, value)
16857 
      for key, value in self.__dict__.iteritems()]
16858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16859 
 
16860 
  def __eq__(self, other):
16861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16862 
 
16863 
  def __ne__(self, other):
16864 
    return not (self == other)
16865 
 
16866 
class getAmazonItemDetails_result:
16867 
  """
16868 
  Attributes:
16869 
   - success
16870 
  """
16871 
 
16872 
  thrift_spec = (
16873 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16874 
  )
16875 
 
16876 
  def __init__(self, success=None,):
16877 
    self.success = success
16878 
 
16879 
  def read(self, iprot):
16880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16882 
      return
16883 
    iprot.readStructBegin()
16884 
    while True:
16885 
      (fname, ftype, fid) = iprot.readFieldBegin()
16886 
      if ftype == TType.STOP:
16887 
        break
16888 
      if fid == 0:
16889 
        if ftype == TType.STRUCT:
16890 
          self.success = Amazonlisted()
16891 
          self.success.read(iprot)
16892 
        else:
16893 
          iprot.skip(ftype)
16894 
      else:
16895 
        iprot.skip(ftype)
16896 
      iprot.readFieldEnd()
16897 
    iprot.readStructEnd()
16898 
 
16899 
  def write(self, oprot):
16900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16902 
      return
16903 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16904 
    if self.success is not None:
16905 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16906 
      self.success.write(oprot)
16907 
      oprot.writeFieldEnd()
16908 
    oprot.writeFieldStop()
16909 
    oprot.writeStructEnd()
16910 
 
16911 
  def validate(self):
16912 
    return
16913 
 
16914 
 
16915 
  def __repr__(self):
16916 
    L = ['%s=%r' % (key, value)
16917 
      for key, value in self.__dict__.iteritems()]
16918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16919 
 
16920 
  def __eq__(self, other):
16921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16922 
 
16923 
  def __ne__(self, other):
16924 
    return not (self == other)
16925 
 
16926 
class updateAmazonItemDetails_args:
16927 
  """
16928 
  Attributes:
16929 
   - itemId
16930 
   - fbaPrice
16931 
   - sellingPrice
16932 
   - isFba
16933 
   - isNonFba
16934 
   - isInventoryOverride
16935 
  """
16936 
 
16937 
  thrift_spec = (
16938 
    None, # 0
16939 
    (1, TType.I64, 'itemId', None, None, ), # 1
16940 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16941 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16942 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16943 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16944 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
16945 
  )
16946 
 
16947 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None,):
16948 
    self.itemId = itemId
16949 
    self.fbaPrice = fbaPrice
16950 
    self.sellingPrice = sellingPrice
16951 
    self.isFba = isFba
16952 
    self.isNonFba = isNonFba
16953 
    self.isInventoryOverride = isInventoryOverride
16954 
 
16955 
  def read(self, iprot):
16956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16958 
      return
16959 
    iprot.readStructBegin()
16960 
    while True:
16961 
      (fname, ftype, fid) = iprot.readFieldBegin()
16962 
      if ftype == TType.STOP:
16963 
        break
16964 
      if fid == 1:
16965 
        if ftype == TType.I64:
16966 
          self.itemId = iprot.readI64();
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      elif fid == 2:
16970 
        if ftype == TType.DOUBLE:
16971 
          self.fbaPrice = iprot.readDouble();
16972 
        else:
16973 
          iprot.skip(ftype)
16974 
      elif fid == 3:
16975 
        if ftype == TType.DOUBLE:
16976 
          self.sellingPrice = iprot.readDouble();
16977 
        else:
16978 
          iprot.skip(ftype)
16979 
      elif fid == 4:
16980 
        if ftype == TType.BOOL:
16981 
          self.isFba = iprot.readBool();
16982 
        else:
16983 
          iprot.skip(ftype)
16984 
      elif fid == 5:
16985 
        if ftype == TType.BOOL:
16986 
          self.isNonFba = iprot.readBool();
16987 
        else:
16988 
          iprot.skip(ftype)
16989 
      elif fid == 6:
16990 
        if ftype == TType.BOOL:
16991 
          self.isInventoryOverride = iprot.readBool();
16992 
        else:
16993 
          iprot.skip(ftype)
16994 
      else:
16995 
        iprot.skip(ftype)
16996 
      iprot.readFieldEnd()
16997 
    iprot.readStructEnd()
16998 
 
16999 
  def write(self, oprot):
17000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17002 
      return
17003 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17004 
    if self.itemId is not None:
17005 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17006 
      oprot.writeI64(self.itemId)
17007 
      oprot.writeFieldEnd()
17008 
    if self.fbaPrice is not None:
17009 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17010 
      oprot.writeDouble(self.fbaPrice)
17011 
      oprot.writeFieldEnd()
17012 
    if self.sellingPrice is not None:
17013 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17014 
      oprot.writeDouble(self.sellingPrice)
17015 
      oprot.writeFieldEnd()
17016 
    if self.isFba is not None:
17017 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17018 
      oprot.writeBool(self.isFba)
17019 
      oprot.writeFieldEnd()
17020 
    if self.isNonFba is not None:
17021 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17022 
      oprot.writeBool(self.isNonFba)
17023 
      oprot.writeFieldEnd()
17024 
    if self.isInventoryOverride is not None:
17025 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17026 
      oprot.writeBool(self.isInventoryOverride)
17027 
      oprot.writeFieldEnd()
17028 
    oprot.writeFieldStop()
17029 
    oprot.writeStructEnd()
17030 
 
17031 
  def validate(self):
17032 
    return
17033 
 
17034 
 
17035 
  def __repr__(self):
17036 
    L = ['%s=%r' % (key, value)
17037 
      for key, value in self.__dict__.iteritems()]
17038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17039 
 
17040 
  def __eq__(self, other):
17041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17042 
 
17043 
  def __ne__(self, other):
17044 
    return not (self == other)
17045 
 
17046 
class updateAmazonItemDetails_result:
17047 
 
17048 
  thrift_spec = (
17049 
  )
17050 
 
17051 
  def read(self, iprot):
17052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17054 
      return
17055 
    iprot.readStructBegin()
17056 
    while True:
17057 
      (fname, ftype, fid) = iprot.readFieldBegin()
17058 
      if ftype == TType.STOP:
17059 
        break
17060 
      else:
17061 
        iprot.skip(ftype)
17062 
      iprot.readFieldEnd()
17063 
    iprot.readStructEnd()
17064 
 
17065 
  def write(self, oprot):
17066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17068 
      return
17069 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17070 
    oprot.writeFieldStop()
17071 
    oprot.writeStructEnd()
17072 
 
17073 
  def validate(self):
17074 
    return
17075 
 
17076 
 
17077 
  def __repr__(self):
17078 
    L = ['%s=%r' % (key, value)
17079 
      for key, value in self.__dict__.iteritems()]
17080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17081 
 
17082 
  def __eq__(self, other):
17083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17084 
 
17085 
  def __ne__(self, other):
17086 
    return not (self == other)
17087 
 
17088 
class addAmazonItem_args:
17089 
  """
17090 
  Attributes:
17091 
   - amazonlisted
17092 
  """
17093 
 
17094 
  thrift_spec = (
17095 
    None, # 0
17096 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17097 
  )
17098 
 
17099 
  def __init__(self, amazonlisted=None,):
17100 
    self.amazonlisted = amazonlisted
17101 
 
17102 
  def read(self, iprot):
17103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17105 
      return
17106 
    iprot.readStructBegin()
17107 
    while True:
17108 
      (fname, ftype, fid) = iprot.readFieldBegin()
17109 
      if ftype == TType.STOP:
17110 
        break
17111 
      if fid == 1:
17112 
        if ftype == TType.STRUCT:
17113 
          self.amazonlisted = Amazonlisted()
17114 
          self.amazonlisted.read(iprot)
17115 
        else:
17116 
          iprot.skip(ftype)
17117 
      else:
17118 
        iprot.skip(ftype)
17119 
      iprot.readFieldEnd()
17120 
    iprot.readStructEnd()
17121 
 
17122 
  def write(self, oprot):
17123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17125 
      return
17126 
    oprot.writeStructBegin('addAmazonItem_args')
17127 
    if self.amazonlisted is not None:
17128 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17129 
      self.amazonlisted.write(oprot)
17130 
      oprot.writeFieldEnd()
17131 
    oprot.writeFieldStop()
17132 
    oprot.writeStructEnd()
17133 
 
17134 
  def validate(self):
17135 
    return
17136 
 
17137 
 
17138 
  def __repr__(self):
17139 
    L = ['%s=%r' % (key, value)
17140 
      for key, value in self.__dict__.iteritems()]
17141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17142 
 
17143 
  def __eq__(self, other):
17144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17145 
 
17146 
  def __ne__(self, other):
17147 
    return not (self == other)
17148 
 
17149 
class addAmazonItem_result:
17150 
 
17151 
  thrift_spec = (
17152 
  )
17153 
 
17154 
  def read(self, iprot):
17155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17157 
      return
17158 
    iprot.readStructBegin()
17159 
    while True:
17160 
      (fname, ftype, fid) = iprot.readFieldBegin()
17161 
      if ftype == TType.STOP:
17162 
        break
17163 
      else:
17164 
        iprot.skip(ftype)
17165 
      iprot.readFieldEnd()
17166 
    iprot.readStructEnd()
17167 
 
17168 
  def write(self, oprot):
17169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17171 
      return
17172 
    oprot.writeStructBegin('addAmazonItem_result')
17173 
    oprot.writeFieldStop()
17174 
    oprot.writeStructEnd()
17175 
 
17176 
  def validate(self):
17177 
    return
17178 
 
17179 
 
17180 
  def __repr__(self):
17181 
    L = ['%s=%r' % (key, value)
17182 
      for key, value in self.__dict__.iteritems()]
17183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17184 
 
17185 
  def __eq__(self, other):
17186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17187 
 
17188 
  def __ne__(self, other):
17189 
    return not (self == other)
7291 vikram.rag 17190 
 
17191 
class getAsinItems_args:
17192 
 
17193 
  thrift_spec = (
17194 
  )
17195 
 
17196 
  def read(self, iprot):
17197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17199 
      return
17200 
    iprot.readStructBegin()
17201 
    while True:
17202 
      (fname, ftype, fid) = iprot.readFieldBegin()
17203 
      if ftype == TType.STOP:
17204 
        break
17205 
      else:
17206 
        iprot.skip(ftype)
17207 
      iprot.readFieldEnd()
17208 
    iprot.readStructEnd()
17209 
 
17210 
  def write(self, oprot):
17211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17213 
      return
17214 
    oprot.writeStructBegin('getAsinItems_args')
17215 
    oprot.writeFieldStop()
17216 
    oprot.writeStructEnd()
17217 
 
17218 
  def validate(self):
17219 
    return
17220 
 
17221 
 
17222 
  def __repr__(self):
17223 
    L = ['%s=%r' % (key, value)
17224 
      for key, value in self.__dict__.iteritems()]
17225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17226 
 
17227 
  def __eq__(self, other):
17228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17229 
 
17230 
  def __ne__(self, other):
17231 
    return not (self == other)
17232 
 
17233 
class getAsinItems_result:
17234 
  """
17235 
  Attributes:
17236 
   - success
17237 
  """
17238 
 
17239 
  thrift_spec = (
17240 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17241 
  )
17242 
 
17243 
  def __init__(self, success=None,):
17244 
    self.success = success
17245 
 
17246 
  def read(self, iprot):
17247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17249 
      return
17250 
    iprot.readStructBegin()
17251 
    while True:
17252 
      (fname, ftype, fid) = iprot.readFieldBegin()
17253 
      if ftype == TType.STOP:
17254 
        break
17255 
      if fid == 0:
17256 
        if ftype == TType.LIST:
17257 
          self.success = []
7306 rajveer 17258 
          (_etype331, _size328) = iprot.readListBegin()
17259 
          for _i332 in xrange(_size328):
17260 
            _elem333 = Item()
17261 
            _elem333.read(iprot)
17262 
            self.success.append(_elem333)
7291 vikram.rag 17263 
          iprot.readListEnd()
17264 
        else:
17265 
          iprot.skip(ftype)
17266 
      else:
17267 
        iprot.skip(ftype)
17268 
      iprot.readFieldEnd()
17269 
    iprot.readStructEnd()
17270 
 
17271 
  def write(self, oprot):
17272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17274 
      return
17275 
    oprot.writeStructBegin('getAsinItems_result')
17276 
    if self.success is not None:
17277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17279 
      for iter334 in self.success:
17280 
        iter334.write(oprot)
7291 vikram.rag 17281 
      oprot.writeListEnd()
17282 
      oprot.writeFieldEnd()
17283 
    oprot.writeFieldStop()
17284 
    oprot.writeStructEnd()
17285 
 
17286 
  def validate(self):
17287 
    return
17288 
 
17289 
 
17290 
  def __repr__(self):
17291 
    L = ['%s=%r' % (key, value)
17292 
      for key, value in self.__dict__.iteritems()]
17293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17294 
 
17295 
  def __eq__(self, other):
17296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17297 
 
17298 
  def __ne__(self, other):
17299 
    return not (self == other)
17300 
 
17301 
class getAllFbaListedItems_args:
17302 
 
17303 
  thrift_spec = (
17304 
  )
17305 
 
17306 
  def read(self, iprot):
17307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17309 
      return
17310 
    iprot.readStructBegin()
17311 
    while True:
17312 
      (fname, ftype, fid) = iprot.readFieldBegin()
17313 
      if ftype == TType.STOP:
17314 
        break
17315 
      else:
17316 
        iprot.skip(ftype)
17317 
      iprot.readFieldEnd()
17318 
    iprot.readStructEnd()
17319 
 
17320 
  def write(self, oprot):
17321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17323 
      return
17324 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17325 
    oprot.writeFieldStop()
17326 
    oprot.writeStructEnd()
17327 
 
17328 
  def validate(self):
17329 
    return
17330 
 
17331 
 
17332 
  def __repr__(self):
17333 
    L = ['%s=%r' % (key, value)
17334 
      for key, value in self.__dict__.iteritems()]
17335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17336 
 
17337 
  def __eq__(self, other):
17338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17339 
 
17340 
  def __ne__(self, other):
17341 
    return not (self == other)
17342 
 
17343 
class getAllFbaListedItems_result:
17344 
  """
17345 
  Attributes:
17346 
   - success
17347 
  """
17348 
 
17349 
  thrift_spec = (
17350 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17351 
  )
17352 
 
17353 
  def __init__(self, success=None,):
17354 
    self.success = success
17355 
 
17356 
  def read(self, iprot):
17357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17359 
      return
17360 
    iprot.readStructBegin()
17361 
    while True:
17362 
      (fname, ftype, fid) = iprot.readFieldBegin()
17363 
      if ftype == TType.STOP:
17364 
        break
17365 
      if fid == 0:
17366 
        if ftype == TType.LIST:
17367 
          self.success = []
7306 rajveer 17368 
          (_etype338, _size335) = iprot.readListBegin()
17369 
          for _i339 in xrange(_size335):
17370 
            _elem340 = Amazonlisted()
17371 
            _elem340.read(iprot)
17372 
            self.success.append(_elem340)
7291 vikram.rag 17373 
          iprot.readListEnd()
17374 
        else:
17375 
          iprot.skip(ftype)
17376 
      else:
17377 
        iprot.skip(ftype)
17378 
      iprot.readFieldEnd()
17379 
    iprot.readStructEnd()
17380 
 
17381 
  def write(self, oprot):
17382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17384 
      return
17385 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17386 
    if self.success is not None:
17387 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17388 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17389 
      for iter341 in self.success:
17390 
        iter341.write(oprot)
7291 vikram.rag 17391 
      oprot.writeListEnd()
17392 
      oprot.writeFieldEnd()
17393 
    oprot.writeFieldStop()
17394 
    oprot.writeStructEnd()
17395 
 
17396 
  def validate(self):
17397 
    return
17398 
 
17399 
 
17400 
  def __repr__(self):
17401 
    L = ['%s=%r' % (key, value)
17402 
      for key, value in self.__dict__.iteritems()]
17403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17404 
 
17405 
  def __eq__(self, other):
17406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17407 
 
17408 
  def __ne__(self, other):
17409 
    return not (self == other)
17410 
 
17411 
class getAllNonFbaListedItems_args:
17412 
 
17413 
  thrift_spec = (
17414 
  )
17415 
 
17416 
  def read(self, iprot):
17417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17419 
      return
17420 
    iprot.readStructBegin()
17421 
    while True:
17422 
      (fname, ftype, fid) = iprot.readFieldBegin()
17423 
      if ftype == TType.STOP:
17424 
        break
17425 
      else:
17426 
        iprot.skip(ftype)
17427 
      iprot.readFieldEnd()
17428 
    iprot.readStructEnd()
17429 
 
17430 
  def write(self, oprot):
17431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17433 
      return
17434 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17435 
    oprot.writeFieldStop()
17436 
    oprot.writeStructEnd()
17437 
 
17438 
  def validate(self):
17439 
    return
17440 
 
17441 
 
17442 
  def __repr__(self):
17443 
    L = ['%s=%r' % (key, value)
17444 
      for key, value in self.__dict__.iteritems()]
17445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17446 
 
17447 
  def __eq__(self, other):
17448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17449 
 
17450 
  def __ne__(self, other):
17451 
    return not (self == other)
17452 
 
17453 
class getAllNonFbaListedItems_result:
17454 
  """
17455 
  Attributes:
17456 
   - success
17457 
  """
17458 
 
17459 
  thrift_spec = (
17460 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17461 
  )
17462 
 
17463 
  def __init__(self, success=None,):
17464 
    self.success = success
17465 
 
17466 
  def read(self, iprot):
17467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17469 
      return
17470 
    iprot.readStructBegin()
17471 
    while True:
17472 
      (fname, ftype, fid) = iprot.readFieldBegin()
17473 
      if ftype == TType.STOP:
17474 
        break
17475 
      if fid == 0:
17476 
        if ftype == TType.LIST:
17477 
          self.success = []
7306 rajveer 17478 
          (_etype345, _size342) = iprot.readListBegin()
17479 
          for _i346 in xrange(_size342):
17480 
            _elem347 = Amazonlisted()
17481 
            _elem347.read(iprot)
17482 
            self.success.append(_elem347)
7291 vikram.rag 17483 
          iprot.readListEnd()
17484 
        else:
17485 
          iprot.skip(ftype)
17486 
      else:
17487 
        iprot.skip(ftype)
17488 
      iprot.readFieldEnd()
17489 
    iprot.readStructEnd()
17490 
 
17491 
  def write(self, oprot):
17492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17494 
      return
17495 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17496 
    if self.success is not None:
17497 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17498 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17499 
      for iter348 in self.success:
17500 
        iter348.write(oprot)
7291 vikram.rag 17501 
      oprot.writeListEnd()
17502 
      oprot.writeFieldEnd()
17503 
    oprot.writeFieldStop()
17504 
    oprot.writeStructEnd()
17505 
 
17506 
  def validate(self):
17507 
    return
17508 
 
17509 
 
17510 
  def __repr__(self):
17511 
    L = ['%s=%r' % (key, value)
17512 
      for key, value in self.__dict__.iteritems()]
17513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17514 
 
17515 
  def __eq__(self, other):
17516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17517 
 
17518 
  def __ne__(self, other):
17519 
    return not (self == other)