Subversion Repositories SmartDukaan

Rev

Rev 7897 | Rev 8139 | 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 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    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.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
6850 kshitij.so 316 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
317 
    """
318 
    Parameters:
319 
     - bannerName
320 
     - imageName
321 
     - link
322 
     - priority
323 
     - isActive
324 
     - hasMap
325 
    """
326 
    pass
327 
 
328 
  def getAllBanners(self, ):
329 
    pass
330 
 
331 
  def deleteBanner(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getBannerDetails(self, bannerName):
339 
    """
340 
    Parameters:
341 
     - bannerName
342 
    """
343 
    pass
344 
 
345 
  def getActiveBanners(self, ):
346 
    pass
347 
 
6849 kshitij.so 348 
  def addBannerMap(self, bannerName, mapLink, coordinates):
349 
    """
350 
    Parameters:
351 
     - bannerName
352 
     - mapLink
353 
     - coordinates
354 
    """
355 
    pass
356 
 
357 
  def deleteBannerMap(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
364 
  def getBannerMapDetails(self, bannerName):
365 
    """
366 
    Parameters:
367 
     - bannerName
368 
    """
369 
    pass
370 
 
5944 mandeep.dh 371 
  def deleteSimilarItem(self, itemId, catalogItemId):
372 
    """
373 
    Delete similar item.
374 
 
375 
    Parameters:
376 
     - itemId
377 
     - catalogItemId
378 
    """
379 
    pass
380 
 
381 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
382 
    """
383 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
384 
    If yes, returns the itemId else returns 0
385 
 
386 
    Parameters:
387 
     - brand
388 
     - modelNumber
389 
     - modelName
390 
     - color
391 
    """
392 
    pass
393 
 
394 
  def validateRiskyStatus(self, itemId):
395 
    """
396 
    Check wether item is risky and change status if inventory is not available for risky items
397 
 
398 
    Parameters:
399 
     - itemId
400 
    """
401 
    pass
402 
 
403 
  def changeItemRiskyFlag(self, itemId, risky):
404 
    """
405 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
406 
 
407 
    Parameters:
408 
     - itemId
409 
     - risky
410 
    """
411 
    pass
412 
 
413 
  def getItemsByRiskyFlag(self, ):
414 
    """
415 
    Returns list of items marked as risky.
416 
    """
417 
    pass
418 
 
419 
  def getItemsForMasterSheet(self, category, brand):
420 
    """
421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
422 
 
423 
    Parameters:
424 
     - category
425 
     - brand
426 
    """
427 
    pass
428 
 
429 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
430 
    """
431 
    Returns list of catalog ids of items with same similarity index as of the given itemId
432 
 
433 
    Parameters:
434 
     - beginIndex
435 
     - totalItems
436 
     - itemId
437 
    """
438 
    pass
439 
 
440 
  def addProductNotification(self, itemId, email):
441 
    """
442 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
443 
 
444 
    Parameters:
445 
     - itemId
446 
     - email
447 
    """
448 
    pass
449 
 
450 
  def sendProductNotifications(self, ):
451 
    """
452 
    Send the product notifications to the users for items which has stock.
453 
    """
454 
    pass
455 
 
456 
  def getAllBrandsByCategory(self, categoryId):
457 
    """
458 
    Returns list of brand names for a given category Id
459 
 
460 
    Parameters:
461 
     - categoryId
462 
    """
463 
    pass
464 
 
465 
  def getAllBrands(self, ):
466 
    """
467 
    Returns list of brand names
468 
    """
469 
    pass
470 
 
471 
  def getAllSources(self, ):
472 
    """
473 
    Return list of all sources
474 
    """
475 
    pass
476 
 
477 
  def getItemPricingBySource(self, itemId, sourceId):
478 
    """
479 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
480 
 
481 
    Parameters:
482 
     - itemId
483 
     - sourceId
484 
    """
485 
    pass
486 
 
487 
  def addSourceItemPricing(self, sourceItemPricing):
488 
    """
489 
    Adds prices to be displayed corresponding to the item if user comes from a source.
490 
    If item is not found or source is not found, it will throw exception.
491 
 
492 
    Parameters:
493 
     - sourceItemPricing
494 
    """
495 
    pass
496 
 
497 
  def getAllSourcePricing(self, itemId):
498 
    """
499 
    Returns the list of source pricing information of an item.
500 
    Raises an exception if item not found corresponding to itemId
501 
 
502 
    Parameters:
503 
     - itemId
504 
    """
505 
    pass
506 
 
507 
  def getItemForSource(self, item_id, sourceId):
508 
    """
509 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
510 
 
511 
    Parameters:
512 
     - item_id
513 
     - sourceId
514 
    """
515 
    pass
516 
 
517 
  def searchItemsInRange(self, searchTerms, offset, limit):
518 
    """
519 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
520 
 
521 
    Parameters:
522 
     - searchTerms
523 
     - offset
524 
     - limit
525 
    """
526 
    pass
527 
 
528 
  def getSearchResultCount(self, searchTerms):
529 
    """
530 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
531 
 
532 
    Parameters:
533 
     - searchTerms
534 
    """
535 
    pass
536 
 
537 
  def getProductNotifications(self, startDateTime):
538 
    """
539 
    Returns a list of product notifications added after a supplied datetime
540 
 
541 
    Parameters:
542 
     - startDateTime
543 
    """
544 
    pass
545 
 
7897 amar.kumar 546 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 547 
    """
548 
    Returns a list of count of requests for product notification against each item
549 
 
550 
    Parameters:
551 
     - startDateTime
7897 amar.kumar 552 
     - categoryId
5944 mandeep.dh 553 
    """
554 
    pass
555 
 
556 
  def addAuthorizationLog(self, itemId, username, reason):
557 
    """
558 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
559 
 
560 
    Parameters:
561 
     - itemId
562 
     - username
563 
     - reason
564 
    """
565 
    pass
566 
 
567 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
568 
    """
569 
    Parameters:
570 
     - catalog_item_id
571 
     - voucherType
572 
     - voucherAmount
573 
    """
574 
    pass
575 
 
576 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
577 
    """
578 
    Parameters:
579 
     - catalog_item_id
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getVoucherAmount(self, itemId, voucherType):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
     - voucherType
589 
    """
590 
    pass
591 
 
592 
  def getAllItemVouchers(self, itemId):
593 
    """
594 
    Parameters:
595 
     - itemId
596 
    """
597 
    pass
598 
 
599 
  def isValidCatalogItemId(self, catalog_item_id):
600 
    """
601 
    Parameters:
602 
     - catalog_item_id
603 
    """
604 
    pass
605 
 
7330 amit.gupta 606 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 607 
    """
608 
    Parameters:
609 
     - itemId
7330 amit.gupta 610 
     - stateId
6039 amit.gupta 611 
     - price
612 
    """
613 
    pass
5944 mandeep.dh 614 
 
6039 amit.gupta 615 
  def getVatAmountForItem(self, itemId, price):
616 
    """
617 
    Parameters:
618 
     - itemId
619 
     - price
620 
    """
621 
    pass
622 
 
6531 vikram.rag 623 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
624 
    """
625 
    Parameters:
626 
     - offset
627 
     - limit
628 
    """
629 
    pass
6039 amit.gupta 630 
 
6821 amar.kumar 631 
  def getAllAliveItems(self, ):
632 
    pass
633 
 
6921 anupam.sin 634 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 635 
    """
636 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 637 
 
6805 anupam.sin 638 
    Parameters:
639 
     - itemId
6921 anupam.sin 640 
     - price
6805 anupam.sin 641 
     - insurerId
642 
     - quantity
643 
    """
644 
    pass
645 
 
646 
  def getInsurer(self, insurerId):
647 
    """
648 
    Parameters:
649 
     - insurerId
650 
    """
651 
    pass
652 
 
6838 vikram.rag 653 
  def getAllInsurers(self, ):
654 
    pass
6805 anupam.sin 655 
 
6962 rajveer 656 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
657 
    """
658 
    Parameters:
659 
     - insurerId
660 
     - amount
661 
    """
662 
    pass
6838 vikram.rag 663 
 
7190 amar.kumar 664 
  def getFreebieForItem(self, itemId):
665 
    """
666 
    Parameters:
667 
     - itemId
668 
    """
669 
    pass
6962 rajveer 670 
 
7190 amar.kumar 671 
  def addOrUpdateFreebieForItem(self, freebieItem):
672 
    """
673 
    Parameters:
674 
     - freebieItem
675 
    """
676 
    pass
677 
 
7272 amit.gupta 678 
  def addOrUpdateBrandInfo(self, brandInfo):
679 
    """
680 
    Parameters:
681 
     - brandInfo
682 
    """
683 
    pass
684 
 
685 
  def getBrandInfo(self, ):
686 
    pass
687 
 
7256 rajveer 688 
  def getStorePricing(self, itemId):
689 
    """
690 
    Parameters:
691 
     - itemId
692 
    """
693 
    pass
7190 amar.kumar 694 
 
7306 rajveer 695 
  def getStorePricings(self, itemIds):
696 
    """
697 
    Parameters:
698 
     - itemIds
699 
    """
700 
    pass
701 
 
7382 rajveer 702 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 703 
    """
704 
    Parameters:
705 
     - sp
7382 rajveer 706 
     - allColors
7265 rajveer 707 
    """
708 
    pass
7256 rajveer 709 
 
7281 kshitij.so 710 
  def getAllAmazonListedItems(self, ):
711 
    pass
7265 rajveer 712 
 
7281 kshitij.so 713 
  def getAmazonItemDetails(self, itemId):
714 
    """
715 
    Parameters:
716 
     - itemId
717 
    """
718 
    pass
719 
 
7367 kshitij.so 720 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 721 
    """
722 
    Parameters:
723 
     - itemId
724 
     - fbaPrice
725 
     - sellingPrice
726 
     - isFba
727 
     - isNonFba
728 
     - isInventoryOverride
7367 kshitij.so 729 
     - handlingTime
730 
     - isCustomTime
7281 kshitij.so 731 
    """
732 
    pass
733 
 
734 
  def addAmazonItem(self, amazonlisted):
735 
    """
736 
    Parameters:
737 
     - amazonlisted
738 
    """
739 
    pass
740 
 
7291 vikram.rag 741 
  def getAsinItems(self, ):
742 
    pass
7281 kshitij.so 743 
 
7291 vikram.rag 744 
  def getAllFbaListedItems(self, ):
745 
    pass
746 
 
747 
  def getAllNonFbaListedItems(self, ):
748 
    pass
749 
 
7460 kshitij.so 750 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
751 
    """
752 
    Parameters:
753 
     - itemId
754 
     - holdInventory
755 
     - defaultInventory
756 
    """
757 
    pass
7291 vikram.rag 758 
 
7770 kshitij.so 759 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
760 
    """
761 
    Parameters:
762 
     - type
763 
     - sku
764 
     - timestamp
765 
    """
766 
    pass
7460 kshitij.so 767 
 
7897 amar.kumar 768 
  def getAllParentCategories(self, ):
769 
    pass
7770 kshitij.so 770 
 
7977 kshitij.so 771 
  def addPageViewEvent(self, pageViewEvents):
772 
    """
773 
    Parameters:
774 
     - pageViewEvents
775 
    """
776 
    pass
7897 amar.kumar 777 
 
7977 kshitij.so 778 
  def addCartEvent(self, cartEvents):
779 
    """
780 
    Parameters:
781 
     - cartEvents
782 
    """
783 
    pass
784 
 
785 
 
5944 mandeep.dh 786 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
787 
  def __init__(self, iprot, oprot=None):
788 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
789 
 
790 
  def addItem(self, item):
791 
    """
792 
    Availability and inventory attributes
793 
 
794 
    Parameters:
795 
     - item
796 
    """
797 
    self.send_addItem(item)
798 
    return self.recv_addItem()
799 
 
800 
  def send_addItem(self, item):
801 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
802 
    args = addItem_args()
803 
    args.item = item
804 
    args.write(self._oprot)
805 
    self._oprot.writeMessageEnd()
806 
    self._oprot.trans.flush()
807 
 
808 
  def recv_addItem(self, ):
809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
810 
    if mtype == TMessageType.EXCEPTION:
811 
      x = TApplicationException()
812 
      x.read(self._iprot)
813 
      self._iprot.readMessageEnd()
814 
      raise x
815 
    result = addItem_result()
816 
    result.read(self._iprot)
817 
    self._iprot.readMessageEnd()
818 
    if result.success is not None:
819 
      return result.success
820 
    if result.cex is not None:
821 
      raise result.cex
822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
823 
 
824 
  def updateItem(self, item):
825 
    """
826 
    Parameters:
827 
     - item
828 
    """
829 
    self.send_updateItem(item)
830 
    return self.recv_updateItem()
831 
 
832 
  def send_updateItem(self, item):
833 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
834 
    args = updateItem_args()
835 
    args.item = item
836 
    args.write(self._oprot)
837 
    self._oprot.writeMessageEnd()
838 
    self._oprot.trans.flush()
839 
 
840 
  def recv_updateItem(self, ):
841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
842 
    if mtype == TMessageType.EXCEPTION:
843 
      x = TApplicationException()
844 
      x.read(self._iprot)
845 
      self._iprot.readMessageEnd()
846 
      raise x
847 
    result = updateItem_result()
848 
    result.read(self._iprot)
849 
    self._iprot.readMessageEnd()
850 
    if result.success is not None:
851 
      return result.success
852 
    if result.cex is not None:
853 
      raise result.cex
854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
855 
 
856 
  def isActive(self, itemId):
857 
    """
858 
    Checks if the item given to the corresponding itemId is active. If it's active,
859 
    whether it's risky and if it's risky, its inventory position.
860 
 
861 
    Parameters:
862 
     - itemId
863 
    """
864 
    self.send_isActive(itemId)
865 
    return self.recv_isActive()
866 
 
867 
  def send_isActive(self, itemId):
868 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
869 
    args = isActive_args()
870 
    args.itemId = itemId
871 
    args.write(self._oprot)
872 
    self._oprot.writeMessageEnd()
873 
    self._oprot.trans.flush()
874 
 
875 
  def recv_isActive(self, ):
876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
877 
    if mtype == TMessageType.EXCEPTION:
878 
      x = TApplicationException()
879 
      x.read(self._iprot)
880 
      self._iprot.readMessageEnd()
881 
      raise x
882 
    result = isActive_result()
883 
    result.read(self._iprot)
884 
    self._iprot.readMessageEnd()
885 
    if result.success is not None:
886 
      return result.success
887 
    if result.isex is not None:
888 
      raise result.isex
889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
890 
 
7438 amit.gupta 891 
  def getItemsStatus(self, itemIds):
892 
    """
893 
    Parameters:
894 
     - itemIds
895 
    """
896 
    self.send_getItemsStatus(itemIds)
897 
    return self.recv_getItemsStatus()
898 
 
899 
  def send_getItemsStatus(self, itemIds):
900 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
901 
    args = getItemsStatus_args()
902 
    args.itemIds = itemIds
903 
    args.write(self._oprot)
904 
    self._oprot.writeMessageEnd()
905 
    self._oprot.trans.flush()
906 
 
907 
  def recv_getItemsStatus(self, ):
908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
909 
    if mtype == TMessageType.EXCEPTION:
910 
      x = TApplicationException()
911 
      x.read(self._iprot)
912 
      self._iprot.readMessageEnd()
913 
      raise x
914 
    result = getItemsStatus_result()
915 
    result.read(self._iprot)
916 
    self._iprot.readMessageEnd()
917 
    if result.success is not None:
918 
      return result.success
919 
    if result.isex is not None:
920 
      raise result.isex
921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
922 
 
5944 mandeep.dh 923 
  def getItemStatusDescription(self, itemId):
924 
    """
925 
    Parameters:
926 
     - itemId
927 
    """
928 
    self.send_getItemStatusDescription(itemId)
929 
    return self.recv_getItemStatusDescription()
930 
 
931 
  def send_getItemStatusDescription(self, itemId):
932 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
933 
    args = getItemStatusDescription_args()
934 
    args.itemId = itemId
935 
    args.write(self._oprot)
936 
    self._oprot.writeMessageEnd()
937 
    self._oprot.trans.flush()
938 
 
939 
  def recv_getItemStatusDescription(self, ):
940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
941 
    if mtype == TMessageType.EXCEPTION:
942 
      x = TApplicationException()
943 
      x.read(self._iprot)
944 
      self._iprot.readMessageEnd()
945 
      raise x
946 
    result = getItemStatusDescription_result()
947 
    result.read(self._iprot)
948 
    self._iprot.readMessageEnd()
949 
    if result.success is not None:
950 
      return result.success
951 
    if result.isex is not None:
952 
      raise result.isex
953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
954 
 
955 
  def startItemOn(self, item_id, timestamp):
956 
    """
957 
    Parameters:
958 
     - item_id
959 
     - timestamp
960 
    """
961 
    self.send_startItemOn(item_id, timestamp)
962 
    self.recv_startItemOn()
963 
 
964 
  def send_startItemOn(self, item_id, timestamp):
965 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
966 
    args = startItemOn_args()
967 
    args.item_id = item_id
968 
    args.timestamp = timestamp
969 
    args.write(self._oprot)
970 
    self._oprot.writeMessageEnd()
971 
    self._oprot.trans.flush()
972 
 
973 
  def recv_startItemOn(self, ):
974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
975 
    if mtype == TMessageType.EXCEPTION:
976 
      x = TApplicationException()
977 
      x.read(self._iprot)
978 
      self._iprot.readMessageEnd()
979 
      raise x
980 
    result = startItemOn_result()
981 
    result.read(self._iprot)
982 
    self._iprot.readMessageEnd()
983 
    if result.cex is not None:
984 
      raise result.cex
985 
    return
986 
 
987 
  def retireItemOn(self, item_id, timestamp):
988 
    """
989 
    Parameters:
990 
     - item_id
991 
     - timestamp
992 
    """
993 
    self.send_retireItemOn(item_id, timestamp)
994 
    self.recv_retireItemOn()
995 
 
996 
  def send_retireItemOn(self, item_id, timestamp):
997 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
998 
    args = retireItemOn_args()
999 
    args.item_id = item_id
1000 
    args.timestamp = timestamp
1001 
    args.write(self._oprot)
1002 
    self._oprot.writeMessageEnd()
1003 
    self._oprot.trans.flush()
1004 
 
1005 
  def recv_retireItemOn(self, ):
1006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1007 
    if mtype == TMessageType.EXCEPTION:
1008 
      x = TApplicationException()
1009 
      x.read(self._iprot)
1010 
      self._iprot.readMessageEnd()
1011 
      raise x
1012 
    result = retireItemOn_result()
1013 
    result.read(self._iprot)
1014 
    self._iprot.readMessageEnd()
1015 
    if result.cex is not None:
1016 
      raise result.cex
1017 
    return
1018 
 
1019 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1020 
    """
1021 
    Parameters:
1022 
     - item_id
1023 
     - timestamp
1024 
     - newstatus
1025 
    """
1026 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1027 
    self.recv_changeItemStatus()
1028 
 
1029 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1030 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1031 
    args = changeItemStatus_args()
1032 
    args.item_id = item_id
1033 
    args.timestamp = timestamp
1034 
    args.newstatus = newstatus
1035 
    args.write(self._oprot)
1036 
    self._oprot.writeMessageEnd()
1037 
    self._oprot.trans.flush()
1038 
 
1039 
  def recv_changeItemStatus(self, ):
1040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1041 
    if mtype == TMessageType.EXCEPTION:
1042 
      x = TApplicationException()
1043 
      x.read(self._iprot)
1044 
      self._iprot.readMessageEnd()
1045 
      raise x
1046 
    result = changeItemStatus_result()
1047 
    result.read(self._iprot)
1048 
    self._iprot.readMessageEnd()
1049 
    if result.cex is not None:
1050 
      raise result.cex
1051 
    return
1052 
 
1053 
  def getItem(self, item_id):
1054 
    """
1055 
    Parameters:
1056 
     - item_id
1057 
    """
1058 
    self.send_getItem(item_id)
1059 
    return self.recv_getItem()
1060 
 
1061 
  def send_getItem(self, item_id):
1062 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1063 
    args = getItem_args()
1064 
    args.item_id = item_id
1065 
    args.write(self._oprot)
1066 
    self._oprot.writeMessageEnd()
1067 
    self._oprot.trans.flush()
1068 
 
1069 
  def recv_getItem(self, ):
1070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1071 
    if mtype == TMessageType.EXCEPTION:
1072 
      x = TApplicationException()
1073 
      x.read(self._iprot)
1074 
      self._iprot.readMessageEnd()
1075 
      raise x
1076 
    result = getItem_result()
1077 
    result.read(self._iprot)
1078 
    self._iprot.readMessageEnd()
1079 
    if result.success is not None:
1080 
      return result.success
1081 
    if result.cex is not None:
1082 
      raise result.cex
1083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1084 
 
1085 
  def getItemsByCatalogId(self, catalog_item_id):
1086 
    """
1087 
    Parameters:
1088 
     - catalog_item_id
1089 
    """
1090 
    self.send_getItemsByCatalogId(catalog_item_id)
1091 
    return self.recv_getItemsByCatalogId()
1092 
 
1093 
  def send_getItemsByCatalogId(self, catalog_item_id):
1094 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1095 
    args = getItemsByCatalogId_args()
1096 
    args.catalog_item_id = catalog_item_id
1097 
    args.write(self._oprot)
1098 
    self._oprot.writeMessageEnd()
1099 
    self._oprot.trans.flush()
1100 
 
1101 
  def recv_getItemsByCatalogId(self, ):
1102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1103 
    if mtype == TMessageType.EXCEPTION:
1104 
      x = TApplicationException()
1105 
      x.read(self._iprot)
1106 
      self._iprot.readMessageEnd()
1107 
      raise x
1108 
    result = getItemsByCatalogId_result()
1109 
    result.read(self._iprot)
1110 
    self._iprot.readMessageEnd()
1111 
    if result.success is not None:
1112 
      return result.success
1113 
    if result.cex is not None:
1114 
      raise result.cex
1115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1116 
 
1117 
  def getValidItemsByCatalogId(self, catalog_item_id):
1118 
    """
1119 
    Parameters:
1120 
     - catalog_item_id
1121 
    """
1122 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1123 
    return self.recv_getValidItemsByCatalogId()
1124 
 
1125 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1126 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1127 
    args = getValidItemsByCatalogId_args()
1128 
    args.catalog_item_id = catalog_item_id
1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_getValidItemsByCatalogId(self, ):
1134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1135 
    if mtype == TMessageType.EXCEPTION:
1136 
      x = TApplicationException()
1137 
      x.read(self._iprot)
1138 
      self._iprot.readMessageEnd()
1139 
      raise x
1140 
    result = getValidItemsByCatalogId_result()
1141 
    result.read(self._iprot)
1142 
    self._iprot.readMessageEnd()
1143 
    if result.success is not None:
1144 
      return result.success
1145 
    if result.cex is not None:
1146 
      raise result.cex
1147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1148 
 
1149 
  def getAllItems(self, isActive):
1150 
    """
1151 
    Parameters:
1152 
     - isActive
1153 
    """
1154 
    self.send_getAllItems(isActive)
1155 
    return self.recv_getAllItems()
1156 
 
1157 
  def send_getAllItems(self, isActive):
1158 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1159 
    args = getAllItems_args()
1160 
    args.isActive = isActive
1161 
    args.write(self._oprot)
1162 
    self._oprot.writeMessageEnd()
1163 
    self._oprot.trans.flush()
1164 
 
1165 
  def recv_getAllItems(self, ):
1166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1167 
    if mtype == TMessageType.EXCEPTION:
1168 
      x = TApplicationException()
1169 
      x.read(self._iprot)
1170 
      self._iprot.readMessageEnd()
1171 
      raise x
1172 
    result = getAllItems_result()
1173 
    result.read(self._iprot)
1174 
    self._iprot.readMessageEnd()
1175 
    if result.success is not None:
1176 
      return result.success
1177 
    if result.cex is not None:
1178 
      raise result.cex
1179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1180 
 
1181 
  def getAllItemsByStatus(self, itemStatus):
1182 
    """
1183 
    Parameters:
1184 
     - itemStatus
1185 
    """
1186 
    self.send_getAllItemsByStatus(itemStatus)
1187 
    return self.recv_getAllItemsByStatus()
1188 
 
1189 
  def send_getAllItemsByStatus(self, itemStatus):
1190 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1191 
    args = getAllItemsByStatus_args()
1192 
    args.itemStatus = itemStatus
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_getAllItemsByStatus(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = getAllItemsByStatus_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
1207 
    if result.success is not None:
1208 
      return result.success
1209 
    if result.cex is not None:
1210 
      raise result.cex
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1212 
 
1213 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1214 
    """
1215 
    Parameters:
1216 
     - entityId
1217 
     - category
1218 
     - brand
1219 
     - modelName
1220 
     - modelNumber
1221 
    """
1222 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1223 
    return self.recv_markItemAsContentComplete()
1224 
 
1225 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1226 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1227 
    args = markItemAsContentComplete_args()
1228 
    args.entityId = entityId
1229 
    args.category = category
1230 
    args.brand = brand
1231 
    args.modelName = modelName
1232 
    args.modelNumber = modelNumber
1233 
    args.write(self._oprot)
1234 
    self._oprot.writeMessageEnd()
1235 
    self._oprot.trans.flush()
1236 
 
1237 
  def recv_markItemAsContentComplete(self, ):
1238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1239 
    if mtype == TMessageType.EXCEPTION:
1240 
      x = TApplicationException()
1241 
      x.read(self._iprot)
1242 
      self._iprot.readMessageEnd()
1243 
      raise x
1244 
    result = markItemAsContentComplete_result()
1245 
    result.read(self._iprot)
1246 
    self._iprot.readMessageEnd()
1247 
    if result.success is not None:
1248 
      return result.success
1249 
    if result.cex is not None:
1250 
      raise result.cex
1251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1252 
 
1253 
  def getAllItemsInRange(self, offset, limit):
1254 
    """
1255 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1256 
 
1257 
    Parameters:
1258 
     - offset
1259 
     - limit
1260 
    """
1261 
    self.send_getAllItemsInRange(offset, limit)
1262 
    return self.recv_getAllItemsInRange()
1263 
 
1264 
  def send_getAllItemsInRange(self, offset, limit):
1265 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1266 
    args = getAllItemsInRange_args()
1267 
    args.offset = offset
1268 
    args.limit = limit
1269 
    args.write(self._oprot)
1270 
    self._oprot.writeMessageEnd()
1271 
    self._oprot.trans.flush()
1272 
 
1273 
  def recv_getAllItemsInRange(self, ):
1274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1275 
    if mtype == TMessageType.EXCEPTION:
1276 
      x = TApplicationException()
1277 
      x.read(self._iprot)
1278 
      self._iprot.readMessageEnd()
1279 
      raise x
1280 
    result = getAllItemsInRange_result()
1281 
    result.read(self._iprot)
1282 
    self._iprot.readMessageEnd()
1283 
    if result.success is not None:
1284 
      return result.success
1285 
    if result.cex is not None:
1286 
      raise result.cex
1287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1288 
 
1289 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1290 
    """
1291 
    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.
1292 
 
1293 
    Parameters:
1294 
     - itemStatus
1295 
     - offset
1296 
     - limit
1297 
    """
1298 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1299 
    return self.recv_getAllItemsByStatusInRange()
1300 
 
1301 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1302 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1303 
    args = getAllItemsByStatusInRange_args()
1304 
    args.itemStatus = itemStatus
1305 
    args.offset = offset
1306 
    args.limit = limit
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_getAllItemsByStatusInRange(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = getAllItemsByStatusInRange_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
1321 
    if result.success is not None:
1322 
      return result.success
1323 
    if result.cex is not None:
1324 
      raise result.cex
1325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1326 
 
1327 
  def getItemCountByStatus(self, useStatus, itemStatus):
1328 
    """
1329 
    Gets a count of all items by status
1330 
 
1331 
    Parameters:
1332 
     - useStatus
1333 
     - itemStatus
1334 
    """
1335 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1336 
    return self.recv_getItemCountByStatus()
1337 
 
1338 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1339 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1340 
    args = getItemCountByStatus_args()
1341 
    args.useStatus = useStatus
1342 
    args.itemStatus = itemStatus
1343 
    args.write(self._oprot)
1344 
    self._oprot.writeMessageEnd()
1345 
    self._oprot.trans.flush()
1346 
 
1347 
  def recv_getItemCountByStatus(self, ):
1348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1349 
    if mtype == TMessageType.EXCEPTION:
1350 
      x = TApplicationException()
1351 
      x.read(self._iprot)
1352 
      self._iprot.readMessageEnd()
1353 
      raise x
1354 
    result = getItemCountByStatus_result()
1355 
    result.read(self._iprot)
1356 
    self._iprot.readMessageEnd()
1357 
    if result.success is not None:
1358 
      return result.success
1359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1360 
 
1361 
  def getBestSellers(self, ):
1362 
    self.send_getBestSellers()
1363 
    return self.recv_getBestSellers()
1364 
 
1365 
  def send_getBestSellers(self, ):
1366 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1367 
    args = getBestSellers_args()
1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
1372 
  def recv_getBestSellers(self, ):
1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
1379 
    result = getBestSellers_result()
1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
1382 
    if result.success is not None:
1383 
      return result.success
1384 
    if result.isex is not None:
1385 
      raise result.isex
1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1387 
 
1388 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1389 
    """
1390 
    Parameters:
1391 
     - beginIndex
1392 
     - totalItems
1393 
     - brand
1394 
     - category
1395 
    """
1396 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1397 
    return self.recv_getBestSellersCatalogIds()
1398 
 
1399 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1400 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1401 
    args = getBestSellersCatalogIds_args()
1402 
    args.beginIndex = beginIndex
1403 
    args.totalItems = totalItems
1404 
    args.brand = brand
1405 
    args.category = category
1406 
    args.write(self._oprot)
1407 
    self._oprot.writeMessageEnd()
1408 
    self._oprot.trans.flush()
1409 
 
1410 
  def recv_getBestSellersCatalogIds(self, ):
1411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1412 
    if mtype == TMessageType.EXCEPTION:
1413 
      x = TApplicationException()
1414 
      x.read(self._iprot)
1415 
      self._iprot.readMessageEnd()
1416 
      raise x
1417 
    result = getBestSellersCatalogIds_result()
1418 
    result.read(self._iprot)
1419 
    self._iprot.readMessageEnd()
1420 
    if result.success is not None:
1421 
      return result.success
1422 
    if result.cex is not None:
1423 
      raise result.cex
1424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1425 
 
1426 
  def getBestSellersCount(self, ):
1427 
    self.send_getBestSellersCount()
1428 
    return self.recv_getBestSellersCount()
1429 
 
1430 
  def send_getBestSellersCount(self, ):
1431 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1432 
    args = getBestSellersCount_args()
1433 
    args.write(self._oprot)
1434 
    self._oprot.writeMessageEnd()
1435 
    self._oprot.trans.flush()
1436 
 
1437 
  def recv_getBestSellersCount(self, ):
1438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1439 
    if mtype == TMessageType.EXCEPTION:
1440 
      x = TApplicationException()
1441 
      x.read(self._iprot)
1442 
      self._iprot.readMessageEnd()
1443 
      raise x
1444 
    result = getBestSellersCount_result()
1445 
    result.read(self._iprot)
1446 
    self._iprot.readMessageEnd()
1447 
    if result.success is not None:
1448 
      return result.success
1449 
    if result.cex is not None:
1450 
      raise result.cex
1451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1452 
 
1453 
  def getBestDeals(self, ):
1454 
    self.send_getBestDeals()
1455 
    return self.recv_getBestDeals()
1456 
 
1457 
  def send_getBestDeals(self, ):
1458 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1459 
    args = getBestDeals_args()
1460 
    args.write(self._oprot)
1461 
    self._oprot.writeMessageEnd()
1462 
    self._oprot.trans.flush()
1463 
 
1464 
  def recv_getBestDeals(self, ):
1465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1466 
    if mtype == TMessageType.EXCEPTION:
1467 
      x = TApplicationException()
1468 
      x.read(self._iprot)
1469 
      self._iprot.readMessageEnd()
1470 
      raise x
1471 
    result = getBestDeals_result()
1472 
    result.read(self._iprot)
1473 
    self._iprot.readMessageEnd()
1474 
    if result.success is not None:
1475 
      return result.success
1476 
    if result.isex is not None:
1477 
      raise result.isex
1478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1479 
 
1480 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1481 
    """
1482 
    Parameters:
1483 
     - beginIndex
1484 
     - totalItems
1485 
     - brand
1486 
     - category
1487 
    """
1488 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1489 
    return self.recv_getBestDealsCatalogIds()
1490 
 
1491 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1492 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1493 
    args = getBestDealsCatalogIds_args()
1494 
    args.beginIndex = beginIndex
1495 
    args.totalItems = totalItems
1496 
    args.brand = brand
1497 
    args.category = category
1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
1502 
  def recv_getBestDealsCatalogIds(self, ):
1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
1509 
    result = getBestDealsCatalogIds_result()
1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
1512 
    if result.success is not None:
1513 
      return result.success
1514 
    if result.cex is not None:
1515 
      raise result.cex
1516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1517 
 
1518 
  def getBestDealsCount(self, ):
1519 
    self.send_getBestDealsCount()
1520 
    return self.recv_getBestDealsCount()
1521 
 
1522 
  def send_getBestDealsCount(self, ):
1523 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1524 
    args = getBestDealsCount_args()
1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getBestDealsCount(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getBestDealsCount_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
1539 
    if result.success is not None:
1540 
      return result.success
1541 
    if result.cex is not None:
1542 
      raise result.cex
1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1544 
 
1545 
  def getComingSoon(self, ):
1546 
    self.send_getComingSoon()
1547 
    return self.recv_getComingSoon()
1548 
 
1549 
  def send_getComingSoon(self, ):
1550 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1551 
    args = getComingSoon_args()
1552 
    args.write(self._oprot)
1553 
    self._oprot.writeMessageEnd()
1554 
    self._oprot.trans.flush()
1555 
 
1556 
  def recv_getComingSoon(self, ):
1557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1558 
    if mtype == TMessageType.EXCEPTION:
1559 
      x = TApplicationException()
1560 
      x.read(self._iprot)
1561 
      self._iprot.readMessageEnd()
1562 
      raise x
1563 
    result = getComingSoon_result()
1564 
    result.read(self._iprot)
1565 
    self._iprot.readMessageEnd()
1566 
    if result.success is not None:
1567 
      return result.success
1568 
    if result.isex is not None:
1569 
      raise result.isex
1570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1571 
 
1572 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1573 
    """
1574 
    Parameters:
1575 
     - beginIndex
1576 
     - totalItems
1577 
     - brand
1578 
     - category
1579 
    """
1580 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1581 
    return self.recv_getComingSoonCatalogIds()
1582 
 
1583 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1584 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1585 
    args = getComingSoonCatalogIds_args()
1586 
    args.beginIndex = beginIndex
1587 
    args.totalItems = totalItems
1588 
    args.brand = brand
1589 
    args.category = category
1590 
    args.write(self._oprot)
1591 
    self._oprot.writeMessageEnd()
1592 
    self._oprot.trans.flush()
1593 
 
1594 
  def recv_getComingSoonCatalogIds(self, ):
1595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1596 
    if mtype == TMessageType.EXCEPTION:
1597 
      x = TApplicationException()
1598 
      x.read(self._iprot)
1599 
      self._iprot.readMessageEnd()
1600 
      raise x
1601 
    result = getComingSoonCatalogIds_result()
1602 
    result.read(self._iprot)
1603 
    self._iprot.readMessageEnd()
1604 
    if result.success is not None:
1605 
      return result.success
1606 
    if result.cex is not None:
1607 
      raise result.cex
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1609 
 
1610 
  def getComingSoonCount(self, ):
1611 
    self.send_getComingSoonCount()
1612 
    return self.recv_getComingSoonCount()
1613 
 
1614 
  def send_getComingSoonCount(self, ):
1615 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1616 
    args = getComingSoonCount_args()
1617 
    args.write(self._oprot)
1618 
    self._oprot.writeMessageEnd()
1619 
    self._oprot.trans.flush()
1620 
 
1621 
  def recv_getComingSoonCount(self, ):
1622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1623 
    if mtype == TMessageType.EXCEPTION:
1624 
      x = TApplicationException()
1625 
      x.read(self._iprot)
1626 
      self._iprot.readMessageEnd()
1627 
      raise x
1628 
    result = getComingSoonCount_result()
1629 
    result.read(self._iprot)
1630 
    self._iprot.readMessageEnd()
1631 
    if result.success is not None:
1632 
      return result.success
1633 
    if result.cex is not None:
1634 
      raise result.cex
1635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1636 
 
1637 
  def getLatestArrivals(self, ):
1638 
    """
1639 
    Returns a list of items sorted in the descending order by start date.
1640 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1641 
    """
1642 
    self.send_getLatestArrivals()
1643 
    return self.recv_getLatestArrivals()
1644 
 
1645 
  def send_getLatestArrivals(self, ):
1646 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1647 
    args = getLatestArrivals_args()
1648 
    args.write(self._oprot)
1649 
    self._oprot.writeMessageEnd()
1650 
    self._oprot.trans.flush()
1651 
 
1652 
  def recv_getLatestArrivals(self, ):
1653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1654 
    if mtype == TMessageType.EXCEPTION:
1655 
      x = TApplicationException()
1656 
      x.read(self._iprot)
1657 
      self._iprot.readMessageEnd()
1658 
      raise x
1659 
    result = getLatestArrivals_result()
1660 
    result.read(self._iprot)
1661 
    self._iprot.readMessageEnd()
1662 
    if result.success is not None:
1663 
      return result.success
1664 
    if result.isex is not None:
1665 
      raise result.isex
1666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1667 
 
1668 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1669 
    """
1670 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1671 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1672 
 
1673 
    Parameters:
1674 
     - beginIndex
1675 
     - totalItems
1676 
     - brand
1677 
     - categories
1678 
    """
1679 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1680 
    return self.recv_getLatestArrivalsCatalogIds()
1681 
 
1682 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1683 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1684 
    args = getLatestArrivalsCatalogIds_args()
1685 
    args.beginIndex = beginIndex
1686 
    args.totalItems = totalItems
1687 
    args.brand = brand
1688 
    args.categories = categories
1689 
    args.write(self._oprot)
1690 
    self._oprot.writeMessageEnd()
1691 
    self._oprot.trans.flush()
1692 
 
1693 
  def recv_getLatestArrivalsCatalogIds(self, ):
1694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1695 
    if mtype == TMessageType.EXCEPTION:
1696 
      x = TApplicationException()
1697 
      x.read(self._iprot)
1698 
      self._iprot.readMessageEnd()
1699 
      raise x
1700 
    result = getLatestArrivalsCatalogIds_result()
1701 
    result.read(self._iprot)
1702 
    self._iprot.readMessageEnd()
1703 
    if result.success is not None:
1704 
      return result.success
1705 
    if result.cex is not None:
1706 
      raise result.cex
1707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1708 
 
1709 
  def getLatestArrivalsCount(self, ):
1710 
    """
1711 
    Get the total number of latest arrivals we are willing to show.
1712 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1713 
    """
1714 
    self.send_getLatestArrivalsCount()
1715 
    return self.recv_getLatestArrivalsCount()
1716 
 
1717 
  def send_getLatestArrivalsCount(self, ):
1718 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1719 
    args = getLatestArrivalsCount_args()
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_getLatestArrivalsCount(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = getLatestArrivalsCount_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
1734 
    if result.success is not None:
1735 
      return result.success
1736 
    if result.cex is not None:
1737 
      raise result.cex
1738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1739 
 
1740 
  def generateNewEntityID(self, ):
1741 
    self.send_generateNewEntityID()
1742 
    return self.recv_generateNewEntityID()
1743 
 
1744 
  def send_generateNewEntityID(self, ):
1745 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1746 
    args = generateNewEntityID_args()
1747 
    args.write(self._oprot)
1748 
    self._oprot.writeMessageEnd()
1749 
    self._oprot.trans.flush()
1750 
 
1751 
  def recv_generateNewEntityID(self, ):
1752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1753 
    if mtype == TMessageType.EXCEPTION:
1754 
      x = TApplicationException()
1755 
      x.read(self._iprot)
1756 
      self._iprot.readMessageEnd()
1757 
      raise x
1758 
    result = generateNewEntityID_result()
1759 
    result.read(self._iprot)
1760 
    self._iprot.readMessageEnd()
1761 
    if result.success is not None:
1762 
      return result.success
1763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1764 
 
1765 
  def addCategory(self, category):
1766 
    """
1767 
    All category related functions
1768 
 
1769 
    Parameters:
1770 
     - category
1771 
    """
1772 
    self.send_addCategory(category)
1773 
    return self.recv_addCategory()
1774 
 
1775 
  def send_addCategory(self, category):
1776 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1777 
    args = addCategory_args()
1778 
    args.category = category
1779 
    args.write(self._oprot)
1780 
    self._oprot.writeMessageEnd()
1781 
    self._oprot.trans.flush()
1782 
 
1783 
  def recv_addCategory(self, ):
1784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1785 
    if mtype == TMessageType.EXCEPTION:
1786 
      x = TApplicationException()
1787 
      x.read(self._iprot)
1788 
      self._iprot.readMessageEnd()
1789 
      raise x
1790 
    result = addCategory_result()
1791 
    result.read(self._iprot)
1792 
    self._iprot.readMessageEnd()
1793 
    if result.success is not None:
1794 
      return result.success
1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1796 
 
1797 
  def getCategory(self, id):
1798 
    """
1799 
    Parameters:
1800 
     - id
1801 
    """
1802 
    self.send_getCategory(id)
1803 
    return self.recv_getCategory()
1804 
 
1805 
  def send_getCategory(self, id):
1806 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1807 
    args = getCategory_args()
1808 
    args.id = id
1809 
    args.write(self._oprot)
1810 
    self._oprot.writeMessageEnd()
1811 
    self._oprot.trans.flush()
1812 
 
1813 
  def recv_getCategory(self, ):
1814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1815 
    if mtype == TMessageType.EXCEPTION:
1816 
      x = TApplicationException()
1817 
      x.read(self._iprot)
1818 
      self._iprot.readMessageEnd()
1819 
      raise x
1820 
    result = getCategory_result()
1821 
    result.read(self._iprot)
1822 
    self._iprot.readMessageEnd()
1823 
    if result.success is not None:
1824 
      return result.success
1825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1826 
 
1827 
  def getAllCategories(self, ):
1828 
    self.send_getAllCategories()
1829 
    return self.recv_getAllCategories()
1830 
 
1831 
  def send_getAllCategories(self, ):
1832 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1833 
    args = getAllCategories_args()
1834 
    args.write(self._oprot)
1835 
    self._oprot.writeMessageEnd()
1836 
    self._oprot.trans.flush()
1837 
 
1838 
  def recv_getAllCategories(self, ):
1839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1840 
    if mtype == TMessageType.EXCEPTION:
1841 
      x = TApplicationException()
1842 
      x.read(self._iprot)
1843 
      self._iprot.readMessageEnd()
1844 
      raise x
1845 
    result = getAllCategories_result()
1846 
    result.read(self._iprot)
1847 
    self._iprot.readMessageEnd()
1848 
    if result.success is not None:
1849 
      return result.success
1850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1851 
 
1852 
  def getAllSimilarItems(self, itemId):
1853 
    """
1854 
    Returns the list of similar items.
1855 
 
1856 
    Parameters:
1857 
     - itemId
1858 
    """
1859 
    self.send_getAllSimilarItems(itemId)
1860 
    return self.recv_getAllSimilarItems()
1861 
 
1862 
  def send_getAllSimilarItems(self, itemId):
1863 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1864 
    args = getAllSimilarItems_args()
1865 
    args.itemId = itemId
1866 
    args.write(self._oprot)
1867 
    self._oprot.writeMessageEnd()
1868 
    self._oprot.trans.flush()
1869 
 
1870 
  def recv_getAllSimilarItems(self, ):
1871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1872 
    if mtype == TMessageType.EXCEPTION:
1873 
      x = TApplicationException()
1874 
      x.read(self._iprot)
1875 
      self._iprot.readMessageEnd()
1876 
      raise x
1877 
    result = getAllSimilarItems_result()
1878 
    result.read(self._iprot)
1879 
    self._iprot.readMessageEnd()
1880 
    if result.success is not None:
1881 
      return result.success
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1883 
 
1884 
  def addSimilarItem(self, itemId, catalogItemId):
1885 
    """
1886 
    Adds similar item.
1887 
 
1888 
    Parameters:
1889 
     - itemId
1890 
     - catalogItemId
1891 
    """
1892 
    self.send_addSimilarItem(itemId, catalogItemId)
1893 
    return self.recv_addSimilarItem()
1894 
 
1895 
  def send_addSimilarItem(self, itemId, catalogItemId):
1896 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1897 
    args = addSimilarItem_args()
1898 
    args.itemId = itemId
1899 
    args.catalogItemId = catalogItemId
1900 
    args.write(self._oprot)
1901 
    self._oprot.writeMessageEnd()
1902 
    self._oprot.trans.flush()
1903 
 
1904 
  def recv_addSimilarItem(self, ):
1905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1906 
    if mtype == TMessageType.EXCEPTION:
1907 
      x = TApplicationException()
1908 
      x.read(self._iprot)
1909 
      self._iprot.readMessageEnd()
1910 
      raise x
1911 
    result = addSimilarItem_result()
1912 
    result.read(self._iprot)
1913 
    self._iprot.readMessageEnd()
1914 
    if result.success is not None:
1915 
      return result.success
1916 
    if result.cex is not None:
1917 
      raise result.cex
1918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1919 
 
6512 kshitij.so 1920 
  def addTag(self, displayName, itemId):
1921 
    """
1922 
    Tag Related
1923 
 
1924 
    Parameters:
1925 
     - displayName
1926 
     - itemId
1927 
    """
1928 
    self.send_addTag(displayName, itemId)
1929 
    return self.recv_addTag()
1930 
 
1931 
  def send_addTag(self, displayName, itemId):
1932 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1933 
    args = addTag_args()
1934 
    args.displayName = displayName
1935 
    args.itemId = itemId
1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
1940 
  def recv_addTag(self, ):
1941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1942 
    if mtype == TMessageType.EXCEPTION:
1943 
      x = TApplicationException()
1944 
      x.read(self._iprot)
1945 
      self._iprot.readMessageEnd()
1946 
      raise x
1947 
    result = addTag_result()
1948 
    result.read(self._iprot)
1949 
    self._iprot.readMessageEnd()
1950 
    if result.success is not None:
1951 
      return result.success
1952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1953 
 
1954 
  def deleteEntityTag(self, displayName, itemId):
1955 
    """
1956 
    Parameters:
1957 
     - displayName
1958 
     - itemId
1959 
    """
1960 
    self.send_deleteEntityTag(displayName, itemId)
1961 
    return self.recv_deleteEntityTag()
1962 
 
1963 
  def send_deleteEntityTag(self, displayName, itemId):
1964 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1965 
    args = deleteEntityTag_args()
1966 
    args.displayName = displayName
1967 
    args.itemId = itemId
1968 
    args.write(self._oprot)
1969 
    self._oprot.writeMessageEnd()
1970 
    self._oprot.trans.flush()
1971 
 
1972 
  def recv_deleteEntityTag(self, ):
1973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1974 
    if mtype == TMessageType.EXCEPTION:
1975 
      x = TApplicationException()
1976 
      x.read(self._iprot)
1977 
      self._iprot.readMessageEnd()
1978 
      raise x
1979 
    result = deleteEntityTag_result()
1980 
    result.read(self._iprot)
1981 
    self._iprot.readMessageEnd()
1982 
    if result.success is not None:
1983 
      return result.success
1984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1985 
 
1986 
  def deleteTag(self, displayName):
1987 
    """
1988 
    Parameters:
1989 
     - displayName
1990 
    """
1991 
    self.send_deleteTag(displayName)
1992 
    return self.recv_deleteTag()
1993 
 
1994 
  def send_deleteTag(self, displayName):
1995 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1996 
    args = deleteTag_args()
1997 
    args.displayName = displayName
1998 
    args.write(self._oprot)
1999 
    self._oprot.writeMessageEnd()
2000 
    self._oprot.trans.flush()
2001 
 
2002 
  def recv_deleteTag(self, ):
2003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2004 
    if mtype == TMessageType.EXCEPTION:
2005 
      x = TApplicationException()
2006 
      x.read(self._iprot)
2007 
      self._iprot.readMessageEnd()
2008 
      raise x
2009 
    result = deleteTag_result()
2010 
    result.read(self._iprot)
2011 
    self._iprot.readMessageEnd()
2012 
    if result.success is not None:
2013 
      return result.success
2014 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2015 
 
2016 
  def getAllTags(self, ):
2017 
    self.send_getAllTags()
2018 
    return self.recv_getAllTags()
2019 
 
2020 
  def send_getAllTags(self, ):
2021 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2022 
    args = getAllTags_args()
2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
2027 
  def recv_getAllTags(self, ):
2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
2034 
    result = getAllTags_result()
2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
2037 
    if result.success is not None:
2038 
      return result.success
2039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2040 
 
2041 
  def getAllEntitiesByTagName(self, displayName):
2042 
    """
2043 
    Parameters:
2044 
     - displayName
2045 
    """
2046 
    self.send_getAllEntitiesByTagName(displayName)
2047 
    return self.recv_getAllEntitiesByTagName()
2048 
 
2049 
  def send_getAllEntitiesByTagName(self, displayName):
2050 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2051 
    args = getAllEntitiesByTagName_args()
2052 
    args.displayName = displayName
2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
2057 
  def recv_getAllEntitiesByTagName(self, ):
2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
2064 
    result = getAllEntitiesByTagName_result()
2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
2067 
    if result.success is not None:
2068 
      return result.success
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2070 
 
6845 amit.gupta 2071 
  def getAllEntityTags(self, ):
2072 
    self.send_getAllEntityTags()
2073 
    return self.recv_getAllEntityTags()
2074 
 
2075 
  def send_getAllEntityTags(self, ):
2076 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2077 
    args = getAllEntityTags_args()
2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
2082 
  def recv_getAllEntityTags(self, ):
2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
2089 
    result = getAllEntityTags_result()
2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
2092 
    if result.success is not None:
2093 
      return result.success
2094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2095 
 
6850 kshitij.so 2096 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2097 
    """
2098 
    Parameters:
2099 
     - bannerName
2100 
     - imageName
2101 
     - link
2102 
     - priority
2103 
     - isActive
2104 
     - hasMap
2105 
    """
2106 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2107 
    return self.recv_addBanner()
2108 
 
2109 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2110 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2111 
    args = addBanner_args()
2112 
    args.bannerName = bannerName
2113 
    args.imageName = imageName
2114 
    args.link = link
2115 
    args.priority = priority
2116 
    args.isActive = isActive
2117 
    args.hasMap = hasMap
2118 
    args.write(self._oprot)
2119 
    self._oprot.writeMessageEnd()
2120 
    self._oprot.trans.flush()
2121 
 
2122 
  def recv_addBanner(self, ):
2123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2124 
    if mtype == TMessageType.EXCEPTION:
2125 
      x = TApplicationException()
2126 
      x.read(self._iprot)
2127 
      self._iprot.readMessageEnd()
2128 
      raise x
2129 
    result = addBanner_result()
2130 
    result.read(self._iprot)
2131 
    self._iprot.readMessageEnd()
2132 
    if result.success is not None:
2133 
      return result.success
2134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2135 
 
2136 
  def getAllBanners(self, ):
2137 
    self.send_getAllBanners()
2138 
    return self.recv_getAllBanners()
2139 
 
2140 
  def send_getAllBanners(self, ):
2141 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2142 
    args = getAllBanners_args()
2143 
    args.write(self._oprot)
2144 
    self._oprot.writeMessageEnd()
2145 
    self._oprot.trans.flush()
2146 
 
2147 
  def recv_getAllBanners(self, ):
2148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2149 
    if mtype == TMessageType.EXCEPTION:
2150 
      x = TApplicationException()
2151 
      x.read(self._iprot)
2152 
      self._iprot.readMessageEnd()
2153 
      raise x
2154 
    result = getAllBanners_result()
2155 
    result.read(self._iprot)
2156 
    self._iprot.readMessageEnd()
2157 
    if result.success is not None:
2158 
      return result.success
2159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2160 
 
2161 
  def deleteBanner(self, bannerName):
2162 
    """
2163 
    Parameters:
2164 
     - bannerName
2165 
    """
2166 
    self.send_deleteBanner(bannerName)
2167 
    return self.recv_deleteBanner()
2168 
 
2169 
  def send_deleteBanner(self, bannerName):
2170 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2171 
    args = deleteBanner_args()
2172 
    args.bannerName = bannerName
2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
2177 
  def recv_deleteBanner(self, ):
2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
2184 
    result = deleteBanner_result()
2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
2187 
    if result.success is not None:
2188 
      return result.success
2189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2190 
 
2191 
  def getBannerDetails(self, bannerName):
2192 
    """
2193 
    Parameters:
2194 
     - bannerName
2195 
    """
2196 
    self.send_getBannerDetails(bannerName)
2197 
    return self.recv_getBannerDetails()
2198 
 
2199 
  def send_getBannerDetails(self, bannerName):
2200 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2201 
    args = getBannerDetails_args()
2202 
    args.bannerName = bannerName
2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
2207 
  def recv_getBannerDetails(self, ):
2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
2214 
    result = getBannerDetails_result()
2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
2217 
    if result.success is not None:
2218 
      return result.success
2219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2220 
 
2221 
  def getActiveBanners(self, ):
2222 
    self.send_getActiveBanners()
2223 
    return self.recv_getActiveBanners()
2224 
 
2225 
  def send_getActiveBanners(self, ):
2226 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2227 
    args = getActiveBanners_args()
2228 
    args.write(self._oprot)
2229 
    self._oprot.writeMessageEnd()
2230 
    self._oprot.trans.flush()
2231 
 
2232 
  def recv_getActiveBanners(self, ):
2233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2234 
    if mtype == TMessageType.EXCEPTION:
2235 
      x = TApplicationException()
2236 
      x.read(self._iprot)
2237 
      self._iprot.readMessageEnd()
2238 
      raise x
2239 
    result = getActiveBanners_result()
2240 
    result.read(self._iprot)
2241 
    self._iprot.readMessageEnd()
2242 
    if result.success is not None:
2243 
      return result.success
2244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2245 
 
6849 kshitij.so 2246 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2247 
    """
2248 
    Parameters:
2249 
     - bannerName
2250 
     - mapLink
2251 
     - coordinates
2252 
    """
2253 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2254 
    return self.recv_addBannerMap()
2255 
 
2256 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2257 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2258 
    args = addBannerMap_args()
2259 
    args.bannerName = bannerName
2260 
    args.mapLink = mapLink
2261 
    args.coordinates = coordinates
2262 
    args.write(self._oprot)
2263 
    self._oprot.writeMessageEnd()
2264 
    self._oprot.trans.flush()
2265 
 
2266 
  def recv_addBannerMap(self, ):
2267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2268 
    if mtype == TMessageType.EXCEPTION:
2269 
      x = TApplicationException()
2270 
      x.read(self._iprot)
2271 
      self._iprot.readMessageEnd()
2272 
      raise x
2273 
    result = addBannerMap_result()
2274 
    result.read(self._iprot)
2275 
    self._iprot.readMessageEnd()
2276 
    if result.success is not None:
2277 
      return result.success
2278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2279 
 
2280 
  def deleteBannerMap(self, bannerName):
2281 
    """
2282 
    Parameters:
2283 
     - bannerName
2284 
    """
2285 
    self.send_deleteBannerMap(bannerName)
2286 
    return self.recv_deleteBannerMap()
2287 
 
2288 
  def send_deleteBannerMap(self, bannerName):
2289 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2290 
    args = deleteBannerMap_args()
2291 
    args.bannerName = bannerName
2292 
    args.write(self._oprot)
2293 
    self._oprot.writeMessageEnd()
2294 
    self._oprot.trans.flush()
2295 
 
2296 
  def recv_deleteBannerMap(self, ):
2297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2298 
    if mtype == TMessageType.EXCEPTION:
2299 
      x = TApplicationException()
2300 
      x.read(self._iprot)
2301 
      self._iprot.readMessageEnd()
2302 
      raise x
2303 
    result = deleteBannerMap_result()
2304 
    result.read(self._iprot)
2305 
    self._iprot.readMessageEnd()
2306 
    if result.success is not None:
2307 
      return result.success
2308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2309 
 
2310 
  def getBannerMapDetails(self, bannerName):
2311 
    """
2312 
    Parameters:
2313 
     - bannerName
2314 
    """
2315 
    self.send_getBannerMapDetails(bannerName)
2316 
    return self.recv_getBannerMapDetails()
2317 
 
2318 
  def send_getBannerMapDetails(self, bannerName):
2319 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2320 
    args = getBannerMapDetails_args()
2321 
    args.bannerName = bannerName
2322 
    args.write(self._oprot)
2323 
    self._oprot.writeMessageEnd()
2324 
    self._oprot.trans.flush()
2325 
 
2326 
  def recv_getBannerMapDetails(self, ):
2327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2328 
    if mtype == TMessageType.EXCEPTION:
2329 
      x = TApplicationException()
2330 
      x.read(self._iprot)
2331 
      self._iprot.readMessageEnd()
2332 
      raise x
2333 
    result = getBannerMapDetails_result()
2334 
    result.read(self._iprot)
2335 
    self._iprot.readMessageEnd()
2336 
    if result.success is not None:
2337 
      return result.success
2338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2339 
 
5944 mandeep.dh 2340 
  def deleteSimilarItem(self, itemId, catalogItemId):
2341 
    """
2342 
    Delete similar item.
2343 
 
2344 
    Parameters:
2345 
     - itemId
2346 
     - catalogItemId
2347 
    """
2348 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2349 
    return self.recv_deleteSimilarItem()
2350 
 
2351 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2352 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2353 
    args = deleteSimilarItem_args()
2354 
    args.itemId = itemId
2355 
    args.catalogItemId = catalogItemId
2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
2360 
  def recv_deleteSimilarItem(self, ):
2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
2367 
    result = deleteSimilarItem_result()
2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
2370 
    if result.success is not None:
2371 
      return result.success
2372 
    if result.cex is not None:
2373 
      raise result.cex
2374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2375 
 
2376 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2377 
    """
2378 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2379 
    If yes, returns the itemId else returns 0
2380 
 
2381 
    Parameters:
2382 
     - brand
2383 
     - modelNumber
2384 
     - modelName
2385 
     - color
2386 
    """
2387 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2388 
    return self.recv_checkSimilarItem()
2389 
 
2390 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2391 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2392 
    args = checkSimilarItem_args()
2393 
    args.brand = brand
2394 
    args.modelNumber = modelNumber
2395 
    args.modelName = modelName
2396 
    args.color = color
2397 
    args.write(self._oprot)
2398 
    self._oprot.writeMessageEnd()
2399 
    self._oprot.trans.flush()
2400 
 
2401 
  def recv_checkSimilarItem(self, ):
2402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2403 
    if mtype == TMessageType.EXCEPTION:
2404 
      x = TApplicationException()
2405 
      x.read(self._iprot)
2406 
      self._iprot.readMessageEnd()
2407 
      raise x
2408 
    result = checkSimilarItem_result()
2409 
    result.read(self._iprot)
2410 
    self._iprot.readMessageEnd()
2411 
    if result.success is not None:
2412 
      return result.success
2413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2414 
 
2415 
  def validateRiskyStatus(self, itemId):
2416 
    """
2417 
    Check wether item is risky and change status if inventory is not available for risky items
2418 
 
2419 
    Parameters:
2420 
     - itemId
2421 
    """
2422 
    self.send_validateRiskyStatus(itemId)
2423 
    self.recv_validateRiskyStatus()
2424 
 
2425 
  def send_validateRiskyStatus(self, itemId):
2426 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2427 
    args = validateRiskyStatus_args()
2428 
    args.itemId = itemId
2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
2433 
  def recv_validateRiskyStatus(self, ):
2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
2440 
    result = validateRiskyStatus_result()
2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
2443 
    return
2444 
 
2445 
  def changeItemRiskyFlag(self, itemId, risky):
2446 
    """
2447 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2448 
 
2449 
    Parameters:
2450 
     - itemId
2451 
     - risky
2452 
    """
2453 
    self.send_changeItemRiskyFlag(itemId, risky)
2454 
    self.recv_changeItemRiskyFlag()
2455 
 
2456 
  def send_changeItemRiskyFlag(self, itemId, risky):
2457 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2458 
    args = changeItemRiskyFlag_args()
2459 
    args.itemId = itemId
2460 
    args.risky = risky
2461 
    args.write(self._oprot)
2462 
    self._oprot.writeMessageEnd()
2463 
    self._oprot.trans.flush()
2464 
 
2465 
  def recv_changeItemRiskyFlag(self, ):
2466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2467 
    if mtype == TMessageType.EXCEPTION:
2468 
      x = TApplicationException()
2469 
      x.read(self._iprot)
2470 
      self._iprot.readMessageEnd()
2471 
      raise x
2472 
    result = changeItemRiskyFlag_result()
2473 
    result.read(self._iprot)
2474 
    self._iprot.readMessageEnd()
2475 
    return
2476 
 
2477 
  def getItemsByRiskyFlag(self, ):
2478 
    """
2479 
    Returns list of items marked as risky.
2480 
    """
2481 
    self.send_getItemsByRiskyFlag()
2482 
    return self.recv_getItemsByRiskyFlag()
2483 
 
2484 
  def send_getItemsByRiskyFlag(self, ):
2485 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2486 
    args = getItemsByRiskyFlag_args()
2487 
    args.write(self._oprot)
2488 
    self._oprot.writeMessageEnd()
2489 
    self._oprot.trans.flush()
2490 
 
2491 
  def recv_getItemsByRiskyFlag(self, ):
2492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2493 
    if mtype == TMessageType.EXCEPTION:
2494 
      x = TApplicationException()
2495 
      x.read(self._iprot)
2496 
      self._iprot.readMessageEnd()
2497 
      raise x
2498 
    result = getItemsByRiskyFlag_result()
2499 
    result.read(self._iprot)
2500 
    self._iprot.readMessageEnd()
2501 
    if result.success is not None:
2502 
      return result.success
2503 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2504 
 
2505 
  def getItemsForMasterSheet(self, category, brand):
2506 
    """
2507 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2508 
 
2509 
    Parameters:
2510 
     - category
2511 
     - brand
2512 
    """
2513 
    self.send_getItemsForMasterSheet(category, brand)
2514 
    return self.recv_getItemsForMasterSheet()
2515 
 
2516 
  def send_getItemsForMasterSheet(self, category, brand):
2517 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2518 
    args = getItemsForMasterSheet_args()
2519 
    args.category = category
2520 
    args.brand = brand
2521 
    args.write(self._oprot)
2522 
    self._oprot.writeMessageEnd()
2523 
    self._oprot.trans.flush()
2524 
 
2525 
  def recv_getItemsForMasterSheet(self, ):
2526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2527 
    if mtype == TMessageType.EXCEPTION:
2528 
      x = TApplicationException()
2529 
      x.read(self._iprot)
2530 
      self._iprot.readMessageEnd()
2531 
      raise x
2532 
    result = getItemsForMasterSheet_result()
2533 
    result.read(self._iprot)
2534 
    self._iprot.readMessageEnd()
2535 
    if result.success is not None:
2536 
      return result.success
2537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2538 
 
2539 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2540 
    """
2541 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2542 
 
2543 
    Parameters:
2544 
     - beginIndex
2545 
     - totalItems
2546 
     - itemId
2547 
    """
2548 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2549 
    return self.recv_getSimilarItemsCatalogIds()
2550 
 
2551 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2552 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2553 
    args = getSimilarItemsCatalogIds_args()
2554 
    args.beginIndex = beginIndex
2555 
    args.totalItems = totalItems
2556 
    args.itemId = itemId
2557 
    args.write(self._oprot)
2558 
    self._oprot.writeMessageEnd()
2559 
    self._oprot.trans.flush()
2560 
 
2561 
  def recv_getSimilarItemsCatalogIds(self, ):
2562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2563 
    if mtype == TMessageType.EXCEPTION:
2564 
      x = TApplicationException()
2565 
      x.read(self._iprot)
2566 
      self._iprot.readMessageEnd()
2567 
      raise x
2568 
    result = getSimilarItemsCatalogIds_result()
2569 
    result.read(self._iprot)
2570 
    self._iprot.readMessageEnd()
2571 
    if result.success is not None:
2572 
      return result.success
2573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2574 
 
2575 
  def addProductNotification(self, itemId, email):
2576 
    """
2577 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2578 
 
2579 
    Parameters:
2580 
     - itemId
2581 
     - email
2582 
    """
2583 
    self.send_addProductNotification(itemId, email)
2584 
    return self.recv_addProductNotification()
2585 
 
2586 
  def send_addProductNotification(self, itemId, email):
2587 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2588 
    args = addProductNotification_args()
2589 
    args.itemId = itemId
2590 
    args.email = email
2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
2595 
  def recv_addProductNotification(self, ):
2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
2602 
    result = addProductNotification_result()
2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
2605 
    if result.success is not None:
2606 
      return result.success
2607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2608 
 
2609 
  def sendProductNotifications(self, ):
2610 
    """
2611 
    Send the product notifications to the users for items which has stock.
2612 
    """
2613 
    self.send_sendProductNotifications()
2614 
    return self.recv_sendProductNotifications()
2615 
 
2616 
  def send_sendProductNotifications(self, ):
2617 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2618 
    args = sendProductNotifications_args()
2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_sendProductNotifications(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = sendProductNotifications_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
2633 
    if result.success is not None:
2634 
      return result.success
2635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2636 
 
2637 
  def getAllBrandsByCategory(self, categoryId):
2638 
    """
2639 
    Returns list of brand names for a given category Id
2640 
 
2641 
    Parameters:
2642 
     - categoryId
2643 
    """
2644 
    self.send_getAllBrandsByCategory(categoryId)
2645 
    return self.recv_getAllBrandsByCategory()
2646 
 
2647 
  def send_getAllBrandsByCategory(self, categoryId):
2648 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2649 
    args = getAllBrandsByCategory_args()
2650 
    args.categoryId = categoryId
2651 
    args.write(self._oprot)
2652 
    self._oprot.writeMessageEnd()
2653 
    self._oprot.trans.flush()
2654 
 
2655 
  def recv_getAllBrandsByCategory(self, ):
2656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2657 
    if mtype == TMessageType.EXCEPTION:
2658 
      x = TApplicationException()
2659 
      x.read(self._iprot)
2660 
      self._iprot.readMessageEnd()
2661 
      raise x
2662 
    result = getAllBrandsByCategory_result()
2663 
    result.read(self._iprot)
2664 
    self._iprot.readMessageEnd()
2665 
    if result.success is not None:
2666 
      return result.success
2667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2668 
 
2669 
  def getAllBrands(self, ):
2670 
    """
2671 
    Returns list of brand names
2672 
    """
2673 
    self.send_getAllBrands()
2674 
    return self.recv_getAllBrands()
2675 
 
2676 
  def send_getAllBrands(self, ):
2677 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2678 
    args = getAllBrands_args()
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_getAllBrands(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = getAllBrands_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    if result.success is not None:
2694 
      return result.success
2695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2696 
 
2697 
  def getAllSources(self, ):
2698 
    """
2699 
    Return list of all sources
2700 
    """
2701 
    self.send_getAllSources()
2702 
    return self.recv_getAllSources()
2703 
 
2704 
  def send_getAllSources(self, ):
2705 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2706 
    args = getAllSources_args()
2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
2711 
  def recv_getAllSources(self, ):
2712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2713 
    if mtype == TMessageType.EXCEPTION:
2714 
      x = TApplicationException()
2715 
      x.read(self._iprot)
2716 
      self._iprot.readMessageEnd()
2717 
      raise x
2718 
    result = getAllSources_result()
2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
2721 
    if result.success is not None:
2722 
      return result.success
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2724 
 
2725 
  def getItemPricingBySource(self, itemId, sourceId):
2726 
    """
2727 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2728 
 
2729 
    Parameters:
2730 
     - itemId
2731 
     - sourceId
2732 
    """
2733 
    self.send_getItemPricingBySource(itemId, sourceId)
2734 
    return self.recv_getItemPricingBySource()
2735 
 
2736 
  def send_getItemPricingBySource(self, itemId, sourceId):
2737 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2738 
    args = getItemPricingBySource_args()
2739 
    args.itemId = itemId
2740 
    args.sourceId = sourceId
2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
2745 
  def recv_getItemPricingBySource(self, ):
2746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2747 
    if mtype == TMessageType.EXCEPTION:
2748 
      x = TApplicationException()
2749 
      x.read(self._iprot)
2750 
      self._iprot.readMessageEnd()
2751 
      raise x
2752 
    result = getItemPricingBySource_result()
2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
2755 
    if result.success is not None:
2756 
      return result.success
2757 
    if result.cex is not None:
2758 
      raise result.cex
2759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2760 
 
2761 
  def addSourceItemPricing(self, sourceItemPricing):
2762 
    """
2763 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2764 
    If item is not found or source is not found, it will throw exception.
2765 
 
2766 
    Parameters:
2767 
     - sourceItemPricing
2768 
    """
2769 
    self.send_addSourceItemPricing(sourceItemPricing)
2770 
    self.recv_addSourceItemPricing()
2771 
 
2772 
  def send_addSourceItemPricing(self, sourceItemPricing):
2773 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2774 
    args = addSourceItemPricing_args()
2775 
    args.sourceItemPricing = sourceItemPricing
2776 
    args.write(self._oprot)
2777 
    self._oprot.writeMessageEnd()
2778 
    self._oprot.trans.flush()
2779 
 
2780 
  def recv_addSourceItemPricing(self, ):
2781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2782 
    if mtype == TMessageType.EXCEPTION:
2783 
      x = TApplicationException()
2784 
      x.read(self._iprot)
2785 
      self._iprot.readMessageEnd()
2786 
      raise x
2787 
    result = addSourceItemPricing_result()
2788 
    result.read(self._iprot)
2789 
    self._iprot.readMessageEnd()
2790 
    if result.cex is not None:
2791 
      raise result.cex
2792 
    return
2793 
 
2794 
  def getAllSourcePricing(self, itemId):
2795 
    """
2796 
    Returns the list of source pricing information of an item.
2797 
    Raises an exception if item not found corresponding to itemId
2798 
 
2799 
    Parameters:
2800 
     - itemId
2801 
    """
2802 
    self.send_getAllSourcePricing(itemId)
2803 
    return self.recv_getAllSourcePricing()
2804 
 
2805 
  def send_getAllSourcePricing(self, itemId):
2806 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2807 
    args = getAllSourcePricing_args()
2808 
    args.itemId = itemId
2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2813 
  def recv_getAllSourcePricing(self, ):
2814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2815 
    if mtype == TMessageType.EXCEPTION:
2816 
      x = TApplicationException()
2817 
      x.read(self._iprot)
2818 
      self._iprot.readMessageEnd()
2819 
      raise x
2820 
    result = getAllSourcePricing_result()
2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
2823 
    if result.success is not None:
2824 
      return result.success
2825 
    if result.cex is not None:
2826 
      raise result.cex
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2828 
 
2829 
  def getItemForSource(self, item_id, sourceId):
2830 
    """
2831 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2832 
 
2833 
    Parameters:
2834 
     - item_id
2835 
     - sourceId
2836 
    """
2837 
    self.send_getItemForSource(item_id, sourceId)
2838 
    return self.recv_getItemForSource()
2839 
 
2840 
  def send_getItemForSource(self, item_id, sourceId):
2841 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2842 
    args = getItemForSource_args()
2843 
    args.item_id = item_id
2844 
    args.sourceId = sourceId
2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2849 
  def recv_getItemForSource(self, ):
2850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2851 
    if mtype == TMessageType.EXCEPTION:
2852 
      x = TApplicationException()
2853 
      x.read(self._iprot)
2854 
      self._iprot.readMessageEnd()
2855 
      raise x
2856 
    result = getItemForSource_result()
2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
2859 
    if result.success is not None:
2860 
      return result.success
2861 
    if result.cex is not None:
2862 
      raise result.cex
2863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2864 
 
2865 
  def searchItemsInRange(self, searchTerms, offset, limit):
2866 
    """
2867 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2868 
 
2869 
    Parameters:
2870 
     - searchTerms
2871 
     - offset
2872 
     - limit
2873 
    """
2874 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2875 
    return self.recv_searchItemsInRange()
2876 
 
2877 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2878 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2879 
    args = searchItemsInRange_args()
2880 
    args.searchTerms = searchTerms
2881 
    args.offset = offset
2882 
    args.limit = limit
2883 
    args.write(self._oprot)
2884 
    self._oprot.writeMessageEnd()
2885 
    self._oprot.trans.flush()
2886 
 
2887 
  def recv_searchItemsInRange(self, ):
2888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2889 
    if mtype == TMessageType.EXCEPTION:
2890 
      x = TApplicationException()
2891 
      x.read(self._iprot)
2892 
      self._iprot.readMessageEnd()
2893 
      raise x
2894 
    result = searchItemsInRange_result()
2895 
    result.read(self._iprot)
2896 
    self._iprot.readMessageEnd()
2897 
    if result.success is not None:
2898 
      return result.success
2899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2900 
 
2901 
  def getSearchResultCount(self, searchTerms):
2902 
    """
2903 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2904 
 
2905 
    Parameters:
2906 
     - searchTerms
2907 
    """
2908 
    self.send_getSearchResultCount(searchTerms)
2909 
    return self.recv_getSearchResultCount()
2910 
 
2911 
  def send_getSearchResultCount(self, searchTerms):
2912 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2913 
    args = getSearchResultCount_args()
2914 
    args.searchTerms = searchTerms
2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_getSearchResultCount(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = getSearchResultCount_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
2929 
    if result.success is not None:
2930 
      return result.success
2931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2932 
 
2933 
  def getProductNotifications(self, startDateTime):
2934 
    """
2935 
    Returns a list of product notifications added after a supplied datetime
2936 
 
2937 
    Parameters:
2938 
     - startDateTime
2939 
    """
2940 
    self.send_getProductNotifications(startDateTime)
2941 
    return self.recv_getProductNotifications()
2942 
 
2943 
  def send_getProductNotifications(self, startDateTime):
2944 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2945 
    args = getProductNotifications_args()
2946 
    args.startDateTime = startDateTime
2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_getProductNotifications(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = getProductNotifications_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
2961 
    if result.success is not None:
2962 
      return result.success
2963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2964 
 
7897 amar.kumar 2965 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2966 
    """
2967 
    Returns a list of count of requests for product notification against each item
2968 
 
2969 
    Parameters:
2970 
     - startDateTime
7897 amar.kumar 2971 
     - categoryId
5944 mandeep.dh 2972 
    """
7897 amar.kumar 2973 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 2974 
    return self.recv_getProductNotificationRequestCount()
2975 
 
7897 amar.kumar 2976 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2977 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2978 
    args = getProductNotificationRequestCount_args()
2979 
    args.startDateTime = startDateTime
7897 amar.kumar 2980 
    args.categoryId = categoryId
5944 mandeep.dh 2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
2985 
  def recv_getProductNotificationRequestCount(self, ):
2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
2992 
    result = getProductNotificationRequestCount_result()
2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
2995 
    if result.success is not None:
2996 
      return result.success
2997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2998 
 
2999 
  def addAuthorizationLog(self, itemId, username, reason):
3000 
    """
3001 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3002 
 
3003 
    Parameters:
3004 
     - itemId
3005 
     - username
3006 
     - reason
3007 
    """
3008 
    self.send_addAuthorizationLog(itemId, username, reason)
3009 
    return self.recv_addAuthorizationLog()
3010 
 
3011 
  def send_addAuthorizationLog(self, itemId, username, reason):
3012 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3013 
    args = addAuthorizationLog_args()
3014 
    args.itemId = itemId
3015 
    args.username = username
3016 
    args.reason = reason
3017 
    args.write(self._oprot)
3018 
    self._oprot.writeMessageEnd()
3019 
    self._oprot.trans.flush()
3020 
 
3021 
  def recv_addAuthorizationLog(self, ):
3022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3023 
    if mtype == TMessageType.EXCEPTION:
3024 
      x = TApplicationException()
3025 
      x.read(self._iprot)
3026 
      self._iprot.readMessageEnd()
3027 
      raise x
3028 
    result = addAuthorizationLog_result()
3029 
    result.read(self._iprot)
3030 
    self._iprot.readMessageEnd()
3031 
    if result.success is not None:
3032 
      return result.success
3033 
    if result.cex is not None:
3034 
      raise result.cex
3035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3036 
 
3037 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3038 
    """
3039 
    Parameters:
3040 
     - catalog_item_id
3041 
     - voucherType
3042 
     - voucherAmount
3043 
    """
3044 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3045 
    return self.recv_addupdateVoucherForItem()
3046 
 
3047 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3048 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3049 
    args = addupdateVoucherForItem_args()
3050 
    args.catalog_item_id = catalog_item_id
3051 
    args.voucherType = voucherType
3052 
    args.voucherAmount = voucherAmount
3053 
    args.write(self._oprot)
3054 
    self._oprot.writeMessageEnd()
3055 
    self._oprot.trans.flush()
3056 
 
3057 
  def recv_addupdateVoucherForItem(self, ):
3058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3059 
    if mtype == TMessageType.EXCEPTION:
3060 
      x = TApplicationException()
3061 
      x.read(self._iprot)
3062 
      self._iprot.readMessageEnd()
3063 
      raise x
3064 
    result = addupdateVoucherForItem_result()
3065 
    result.read(self._iprot)
3066 
    self._iprot.readMessageEnd()
3067 
    if result.success is not None:
3068 
      return result.success
3069 
    if result.cex is not None:
3070 
      raise result.cex
3071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3072 
 
3073 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3074 
    """
3075 
    Parameters:
3076 
     - catalog_item_id
3077 
     - voucherType
3078 
    """
3079 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3080 
    return self.recv_deleteVoucherForItem()
3081 
 
3082 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3083 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3084 
    args = deleteVoucherForItem_args()
3085 
    args.catalog_item_id = catalog_item_id
3086 
    args.voucherType = voucherType
3087 
    args.write(self._oprot)
3088 
    self._oprot.writeMessageEnd()
3089 
    self._oprot.trans.flush()
3090 
 
3091 
  def recv_deleteVoucherForItem(self, ):
3092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3093 
    if mtype == TMessageType.EXCEPTION:
3094 
      x = TApplicationException()
3095 
      x.read(self._iprot)
3096 
      self._iprot.readMessageEnd()
3097 
      raise x
3098 
    result = deleteVoucherForItem_result()
3099 
    result.read(self._iprot)
3100 
    self._iprot.readMessageEnd()
3101 
    if result.success is not None:
3102 
      return result.success
3103 
    if result.cex is not None:
3104 
      raise result.cex
3105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3106 
 
3107 
  def getVoucherAmount(self, itemId, voucherType):
3108 
    """
3109 
    Parameters:
3110 
     - itemId
3111 
     - voucherType
3112 
    """
3113 
    self.send_getVoucherAmount(itemId, voucherType)
3114 
    return self.recv_getVoucherAmount()
3115 
 
3116 
  def send_getVoucherAmount(self, itemId, voucherType):
3117 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3118 
    args = getVoucherAmount_args()
3119 
    args.itemId = itemId
3120 
    args.voucherType = voucherType
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_getVoucherAmount(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = getVoucherAmount_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3135 
    if result.success is not None:
3136 
      return result.success
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3138 
 
3139 
  def getAllItemVouchers(self, itemId):
3140 
    """
3141 
    Parameters:
3142 
     - itemId
3143 
    """
3144 
    self.send_getAllItemVouchers(itemId)
3145 
    return self.recv_getAllItemVouchers()
3146 
 
3147 
  def send_getAllItemVouchers(self, itemId):
3148 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3149 
    args = getAllItemVouchers_args()
3150 
    args.itemId = itemId
3151 
    args.write(self._oprot)
3152 
    self._oprot.writeMessageEnd()
3153 
    self._oprot.trans.flush()
3154 
 
3155 
  def recv_getAllItemVouchers(self, ):
3156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3157 
    if mtype == TMessageType.EXCEPTION:
3158 
      x = TApplicationException()
3159 
      x.read(self._iprot)
3160 
      self._iprot.readMessageEnd()
3161 
      raise x
3162 
    result = getAllItemVouchers_result()
3163 
    result.read(self._iprot)
3164 
    self._iprot.readMessageEnd()
3165 
    if result.success is not None:
3166 
      return result.success
3167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3168 
 
3169 
  def isValidCatalogItemId(self, catalog_item_id):
3170 
    """
3171 
    Parameters:
3172 
     - catalog_item_id
3173 
    """
3174 
    self.send_isValidCatalogItemId(catalog_item_id)
3175 
    return self.recv_isValidCatalogItemId()
3176 
 
3177 
  def send_isValidCatalogItemId(self, catalog_item_id):
3178 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3179 
    args = isValidCatalogItemId_args()
3180 
    args.catalog_item_id = catalog_item_id
3181 
    args.write(self._oprot)
3182 
    self._oprot.writeMessageEnd()
3183 
    self._oprot.trans.flush()
3184 
 
3185 
  def recv_isValidCatalogItemId(self, ):
3186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3187 
    if mtype == TMessageType.EXCEPTION:
3188 
      x = TApplicationException()
3189 
      x.read(self._iprot)
3190 
      self._iprot.readMessageEnd()
3191 
      raise x
3192 
    result = isValidCatalogItemId_result()
3193 
    result.read(self._iprot)
3194 
    self._iprot.readMessageEnd()
3195 
    if result.success is not None:
3196 
      return result.success
3197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3198 
 
7330 amit.gupta 3199 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3200 
    """
3201 
    Parameters:
3202 
     - itemId
7330 amit.gupta 3203 
     - stateId
6039 amit.gupta 3204 
     - price
3205 
    """
7330 amit.gupta 3206 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3207 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3208 
 
7330 amit.gupta 3209 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3210 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3211 
    args = getVatPercentageForItem_args()
3212 
    args.itemId = itemId
7330 amit.gupta 3213 
    args.stateId = stateId
6039 amit.gupta 3214 
    args.price = price
3215 
    args.write(self._oprot)
3216 
    self._oprot.writeMessageEnd()
3217 
    self._oprot.trans.flush()
3218 
 
3219 
  def recv_getVatPercentageForItem(self, ):
3220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3221 
    if mtype == TMessageType.EXCEPTION:
3222 
      x = TApplicationException()
3223 
      x.read(self._iprot)
3224 
      self._iprot.readMessageEnd()
3225 
      raise x
3226 
    result = getVatPercentageForItem_result()
3227 
    result.read(self._iprot)
3228 
    self._iprot.readMessageEnd()
3229 
    if result.success is not None:
3230 
      return result.success
7340 amit.gupta 3231 
    if result.cex is not None:
3232 
      raise result.cex
6039 amit.gupta 3233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3234 
 
3235 
  def getVatAmountForItem(self, itemId, price):
3236 
    """
3237 
    Parameters:
3238 
     - itemId
3239 
     - price
3240 
    """
3241 
    self.send_getVatAmountForItem(itemId, price)
3242 
    return self.recv_getVatAmountForItem()
3243 
 
3244 
  def send_getVatAmountForItem(self, itemId, price):
3245 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3246 
    args = getVatAmountForItem_args()
3247 
    args.itemId = itemId
3248 
    args.price = price
3249 
    args.write(self._oprot)
3250 
    self._oprot.writeMessageEnd()
3251 
    self._oprot.trans.flush()
3252 
 
3253 
  def recv_getVatAmountForItem(self, ):
3254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3255 
    if mtype == TMessageType.EXCEPTION:
3256 
      x = TApplicationException()
3257 
      x.read(self._iprot)
3258 
      self._iprot.readMessageEnd()
3259 
      raise x
3260 
    result = getVatAmountForItem_result()
3261 
    result.read(self._iprot)
3262 
    self._iprot.readMessageEnd()
3263 
    if result.success is not None:
3264 
      return result.success
3265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3266 
 
6531 vikram.rag 3267 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3268 
    """
3269 
    Parameters:
3270 
     - offset
3271 
     - limit
3272 
    """
3273 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3274 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3275 
 
6531 vikram.rag 3276 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3277 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3278 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3279 
    args.offset = offset
3280 
    args.limit = limit
3281 
    args.write(self._oprot)
3282 
    self._oprot.writeMessageEnd()
3283 
    self._oprot.trans.flush()
3284 
 
3285 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3287 
    if mtype == TMessageType.EXCEPTION:
3288 
      x = TApplicationException()
3289 
      x.read(self._iprot)
3290 
      self._iprot.readMessageEnd()
3291 
      raise x
3292 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3293 
    result.read(self._iprot)
3294 
    self._iprot.readMessageEnd()
3295 
    if result.success is not None:
3296 
      return result.success
3297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3298 
 
6821 amar.kumar 3299 
  def getAllAliveItems(self, ):
3300 
    self.send_getAllAliveItems()
3301 
    return self.recv_getAllAliveItems()
3302 
 
3303 
  def send_getAllAliveItems(self, ):
3304 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3305 
    args = getAllAliveItems_args()
3306 
    args.write(self._oprot)
3307 
    self._oprot.writeMessageEnd()
3308 
    self._oprot.trans.flush()
3309 
 
3310 
  def recv_getAllAliveItems(self, ):
3311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3312 
    if mtype == TMessageType.EXCEPTION:
3313 
      x = TApplicationException()
3314 
      x.read(self._iprot)
3315 
      self._iprot.readMessageEnd()
3316 
      raise x
3317 
    result = getAllAliveItems_result()
3318 
    result.read(self._iprot)
3319 
    self._iprot.readMessageEnd()
3320 
    if result.success is not None:
3321 
      return result.success
3322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3323 
 
6921 anupam.sin 3324 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3325 
    """
3326 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3327 
 
6805 anupam.sin 3328 
    Parameters:
3329 
     - itemId
6921 anupam.sin 3330 
     - price
6805 anupam.sin 3331 
     - insurerId
3332 
     - quantity
3333 
    """
6921 anupam.sin 3334 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3335 
    return self.recv_getInsuranceAmount()
3336 
 
6921 anupam.sin 3337 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3338 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3339 
    args = getInsuranceAmount_args()
3340 
    args.itemId = itemId
6921 anupam.sin 3341 
    args.price = price
6805 anupam.sin 3342 
    args.insurerId = insurerId
3343 
    args.quantity = quantity
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_getInsuranceAmount(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = getInsuranceAmount_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3361 
 
3362 
  def getInsurer(self, insurerId):
3363 
    """
3364 
    Parameters:
3365 
     - insurerId
3366 
    """
3367 
    self.send_getInsurer(insurerId)
3368 
    return self.recv_getInsurer()
3369 
 
3370 
  def send_getInsurer(self, insurerId):
3371 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3372 
    args = getInsurer_args()
3373 
    args.insurerId = insurerId
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_getInsurer(self, ):
3379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3380 
    if mtype == TMessageType.EXCEPTION:
3381 
      x = TApplicationException()
3382 
      x.read(self._iprot)
3383 
      self._iprot.readMessageEnd()
3384 
      raise x
3385 
    result = getInsurer_result()
3386 
    result.read(self._iprot)
3387 
    self._iprot.readMessageEnd()
3388 
    if result.success is not None:
3389 
      return result.success
3390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3391 
 
6838 vikram.rag 3392 
  def getAllInsurers(self, ):
3393 
    self.send_getAllInsurers()
3394 
    return self.recv_getAllInsurers()
6805 anupam.sin 3395 
 
6838 vikram.rag 3396 
  def send_getAllInsurers(self, ):
3397 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3398 
    args = getAllInsurers_args()
3399 
    args.write(self._oprot)
3400 
    self._oprot.writeMessageEnd()
3401 
    self._oprot.trans.flush()
3402 
 
3403 
  def recv_getAllInsurers(self, ):
3404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3405 
    if mtype == TMessageType.EXCEPTION:
3406 
      x = TApplicationException()
3407 
      x.read(self._iprot)
3408 
      self._iprot.readMessageEnd()
3409 
      raise x
3410 
    result = getAllInsurers_result()
3411 
    result.read(self._iprot)
3412 
    self._iprot.readMessageEnd()
3413 
    if result.success is not None:
3414 
      return result.success
3415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3416 
 
6962 rajveer 3417 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3418 
    """
3419 
    Parameters:
3420 
     - insurerId
3421 
     - amount
3422 
    """
3423 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3424 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3425 
 
6962 rajveer 3426 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3427 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3428 
    args = updateInsuranceDeclaredAmount_args()
3429 
    args.insurerId = insurerId
3430 
    args.amount = amount
3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_updateInsuranceDeclaredAmount(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = updateInsuranceDeclaredAmount_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    return
3446 
 
7190 amar.kumar 3447 
  def getFreebieForItem(self, itemId):
3448 
    """
3449 
    Parameters:
3450 
     - itemId
3451 
    """
3452 
    self.send_getFreebieForItem(itemId)
3453 
    return self.recv_getFreebieForItem()
6962 rajveer 3454 
 
7190 amar.kumar 3455 
  def send_getFreebieForItem(self, itemId):
3456 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3457 
    args = getFreebieForItem_args()
3458 
    args.itemId = itemId
3459 
    args.write(self._oprot)
3460 
    self._oprot.writeMessageEnd()
3461 
    self._oprot.trans.flush()
3462 
 
3463 
  def recv_getFreebieForItem(self, ):
3464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3465 
    if mtype == TMessageType.EXCEPTION:
3466 
      x = TApplicationException()
3467 
      x.read(self._iprot)
3468 
      self._iprot.readMessageEnd()
3469 
      raise x
3470 
    result = getFreebieForItem_result()
3471 
    result.read(self._iprot)
3472 
    self._iprot.readMessageEnd()
3473 
    if result.success is not None:
3474 
      return result.success
3475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3476 
 
3477 
  def addOrUpdateFreebieForItem(self, freebieItem):
3478 
    """
3479 
    Parameters:
3480 
     - freebieItem
3481 
    """
3482 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3483 
    self.recv_addOrUpdateFreebieForItem()
3484 
 
3485 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3486 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3487 
    args = addOrUpdateFreebieForItem_args()
3488 
    args.freebieItem = freebieItem
3489 
    args.write(self._oprot)
3490 
    self._oprot.writeMessageEnd()
3491 
    self._oprot.trans.flush()
3492 
 
3493 
  def recv_addOrUpdateFreebieForItem(self, ):
3494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3495 
    if mtype == TMessageType.EXCEPTION:
3496 
      x = TApplicationException()
3497 
      x.read(self._iprot)
3498 
      self._iprot.readMessageEnd()
3499 
      raise x
3500 
    result = addOrUpdateFreebieForItem_result()
3501 
    result.read(self._iprot)
3502 
    self._iprot.readMessageEnd()
3503 
    return
3504 
 
7272 amit.gupta 3505 
  def addOrUpdateBrandInfo(self, brandInfo):
3506 
    """
3507 
    Parameters:
3508 
     - brandInfo
3509 
    """
3510 
    self.send_addOrUpdateBrandInfo(brandInfo)
3511 
    self.recv_addOrUpdateBrandInfo()
3512 
 
3513 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3514 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3515 
    args = addOrUpdateBrandInfo_args()
3516 
    args.brandInfo = brandInfo
3517 
    args.write(self._oprot)
3518 
    self._oprot.writeMessageEnd()
3519 
    self._oprot.trans.flush()
3520 
 
3521 
  def recv_addOrUpdateBrandInfo(self, ):
3522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3523 
    if mtype == TMessageType.EXCEPTION:
3524 
      x = TApplicationException()
3525 
      x.read(self._iprot)
3526 
      self._iprot.readMessageEnd()
3527 
      raise x
3528 
    result = addOrUpdateBrandInfo_result()
3529 
    result.read(self._iprot)
3530 
    self._iprot.readMessageEnd()
3531 
    return
3532 
 
3533 
  def getBrandInfo(self, ):
3534 
    self.send_getBrandInfo()
3535 
    return self.recv_getBrandInfo()
3536 
 
3537 
  def send_getBrandInfo(self, ):
3538 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3539 
    args = getBrandInfo_args()
3540 
    args.write(self._oprot)
3541 
    self._oprot.writeMessageEnd()
3542 
    self._oprot.trans.flush()
3543 
 
3544 
  def recv_getBrandInfo(self, ):
3545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3546 
    if mtype == TMessageType.EXCEPTION:
3547 
      x = TApplicationException()
3548 
      x.read(self._iprot)
3549 
      self._iprot.readMessageEnd()
3550 
      raise x
3551 
    result = getBrandInfo_result()
3552 
    result.read(self._iprot)
3553 
    self._iprot.readMessageEnd()
3554 
    if result.success is not None:
3555 
      return result.success
3556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3557 
 
7256 rajveer 3558 
  def getStorePricing(self, itemId):
3559 
    """
3560 
    Parameters:
3561 
     - itemId
3562 
    """
3563 
    self.send_getStorePricing(itemId)
3564 
    return self.recv_getStorePricing()
7190 amar.kumar 3565 
 
7256 rajveer 3566 
  def send_getStorePricing(self, itemId):
3567 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3568 
    args = getStorePricing_args()
3569 
    args.itemId = itemId
3570 
    args.write(self._oprot)
3571 
    self._oprot.writeMessageEnd()
3572 
    self._oprot.trans.flush()
3573 
 
3574 
  def recv_getStorePricing(self, ):
3575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3576 
    if mtype == TMessageType.EXCEPTION:
3577 
      x = TApplicationException()
3578 
      x.read(self._iprot)
3579 
      self._iprot.readMessageEnd()
3580 
      raise x
3581 
    result = getStorePricing_result()
3582 
    result.read(self._iprot)
3583 
    self._iprot.readMessageEnd()
3584 
    if result.success is not None:
3585 
      return result.success
3586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3587 
 
7306 rajveer 3588 
  def getStorePricings(self, itemIds):
3589 
    """
3590 
    Parameters:
3591 
     - itemIds
3592 
    """
3593 
    self.send_getStorePricings(itemIds)
3594 
    return self.recv_getStorePricings()
3595 
 
3596 
  def send_getStorePricings(self, itemIds):
3597 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3598 
    args = getStorePricings_args()
3599 
    args.itemIds = itemIds
3600 
    args.write(self._oprot)
3601 
    self._oprot.writeMessageEnd()
3602 
    self._oprot.trans.flush()
3603 
 
3604 
  def recv_getStorePricings(self, ):
3605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3606 
    if mtype == TMessageType.EXCEPTION:
3607 
      x = TApplicationException()
3608 
      x.read(self._iprot)
3609 
      self._iprot.readMessageEnd()
3610 
      raise x
3611 
    result = getStorePricings_result()
3612 
    result.read(self._iprot)
3613 
    self._iprot.readMessageEnd()
3614 
    if result.success is not None:
3615 
      return result.success
3616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3617 
 
7382 rajveer 3618 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3619 
    """
3620 
    Parameters:
3621 
     - sp
7382 rajveer 3622 
     - allColors
7265 rajveer 3623 
    """
7382 rajveer 3624 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3625 
    self.recv_updateStorePricing()
7256 rajveer 3626 
 
7382 rajveer 3627 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3628 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3629 
    args = updateStorePricing_args()
3630 
    args.sp = sp
7382 rajveer 3631 
    args.allColors = allColors
7265 rajveer 3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_updateStorePricing(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = updateStorePricing_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
3646 
    return
3647 
 
7281 kshitij.so 3648 
  def getAllAmazonListedItems(self, ):
3649 
    self.send_getAllAmazonListedItems()
3650 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3651 
 
7281 kshitij.so 3652 
  def send_getAllAmazonListedItems(self, ):
3653 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3654 
    args = getAllAmazonListedItems_args()
3655 
    args.write(self._oprot)
3656 
    self._oprot.writeMessageEnd()
3657 
    self._oprot.trans.flush()
3658 
 
3659 
  def recv_getAllAmazonListedItems(self, ):
3660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3661 
    if mtype == TMessageType.EXCEPTION:
3662 
      x = TApplicationException()
3663 
      x.read(self._iprot)
3664 
      self._iprot.readMessageEnd()
3665 
      raise x
3666 
    result = getAllAmazonListedItems_result()
3667 
    result.read(self._iprot)
3668 
    self._iprot.readMessageEnd()
3669 
    if result.success is not None:
3670 
      return result.success
3671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3672 
 
3673 
  def getAmazonItemDetails(self, itemId):
3674 
    """
3675 
    Parameters:
3676 
     - itemId
3677 
    """
3678 
    self.send_getAmazonItemDetails(itemId)
3679 
    return self.recv_getAmazonItemDetails()
3680 
 
3681 
  def send_getAmazonItemDetails(self, itemId):
3682 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3683 
    args = getAmazonItemDetails_args()
3684 
    args.itemId = itemId
3685 
    args.write(self._oprot)
3686 
    self._oprot.writeMessageEnd()
3687 
    self._oprot.trans.flush()
3688 
 
3689 
  def recv_getAmazonItemDetails(self, ):
3690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3691 
    if mtype == TMessageType.EXCEPTION:
3692 
      x = TApplicationException()
3693 
      x.read(self._iprot)
3694 
      self._iprot.readMessageEnd()
3695 
      raise x
3696 
    result = getAmazonItemDetails_result()
3697 
    result.read(self._iprot)
3698 
    self._iprot.readMessageEnd()
3699 
    if result.success is not None:
3700 
      return result.success
3701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3702 
 
7367 kshitij.so 3703 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3704 
    """
3705 
    Parameters:
3706 
     - itemId
3707 
     - fbaPrice
3708 
     - sellingPrice
3709 
     - isFba
3710 
     - isNonFba
3711 
     - isInventoryOverride
7367 kshitij.so 3712 
     - handlingTime
3713 
     - isCustomTime
7281 kshitij.so 3714 
    """
7367 kshitij.so 3715 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3716 
    self.recv_updateAmazonItemDetails()
3717 
 
7367 kshitij.so 3718 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3719 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3720 
    args = updateAmazonItemDetails_args()
3721 
    args.itemId = itemId
3722 
    args.fbaPrice = fbaPrice
3723 
    args.sellingPrice = sellingPrice
3724 
    args.isFba = isFba
3725 
    args.isNonFba = isNonFba
3726 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3727 
    args.handlingTime = handlingTime
3728 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3729 
    args.write(self._oprot)
3730 
    self._oprot.writeMessageEnd()
3731 
    self._oprot.trans.flush()
3732 
 
3733 
  def recv_updateAmazonItemDetails(self, ):
3734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3735 
    if mtype == TMessageType.EXCEPTION:
3736 
      x = TApplicationException()
3737 
      x.read(self._iprot)
3738 
      self._iprot.readMessageEnd()
3739 
      raise x
3740 
    result = updateAmazonItemDetails_result()
3741 
    result.read(self._iprot)
3742 
    self._iprot.readMessageEnd()
3743 
    return
3744 
 
3745 
  def addAmazonItem(self, amazonlisted):
3746 
    """
3747 
    Parameters:
3748 
     - amazonlisted
3749 
    """
3750 
    self.send_addAmazonItem(amazonlisted)
3751 
    self.recv_addAmazonItem()
3752 
 
3753 
  def send_addAmazonItem(self, amazonlisted):
3754 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3755 
    args = addAmazonItem_args()
3756 
    args.amazonlisted = amazonlisted
3757 
    args.write(self._oprot)
3758 
    self._oprot.writeMessageEnd()
3759 
    self._oprot.trans.flush()
3760 
 
3761 
  def recv_addAmazonItem(self, ):
3762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3763 
    if mtype == TMessageType.EXCEPTION:
3764 
      x = TApplicationException()
3765 
      x.read(self._iprot)
3766 
      self._iprot.readMessageEnd()
3767 
      raise x
3768 
    result = addAmazonItem_result()
3769 
    result.read(self._iprot)
3770 
    self._iprot.readMessageEnd()
3771 
    return
3772 
 
7291 vikram.rag 3773 
  def getAsinItems(self, ):
3774 
    self.send_getAsinItems()
3775 
    return self.recv_getAsinItems()
7281 kshitij.so 3776 
 
7291 vikram.rag 3777 
  def send_getAsinItems(self, ):
3778 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3779 
    args = getAsinItems_args()
3780 
    args.write(self._oprot)
3781 
    self._oprot.writeMessageEnd()
3782 
    self._oprot.trans.flush()
3783 
 
3784 
  def recv_getAsinItems(self, ):
3785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3786 
    if mtype == TMessageType.EXCEPTION:
3787 
      x = TApplicationException()
3788 
      x.read(self._iprot)
3789 
      self._iprot.readMessageEnd()
3790 
      raise x
3791 
    result = getAsinItems_result()
3792 
    result.read(self._iprot)
3793 
    self._iprot.readMessageEnd()
3794 
    if result.success is not None:
3795 
      return result.success
3796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3797 
 
3798 
  def getAllFbaListedItems(self, ):
3799 
    self.send_getAllFbaListedItems()
3800 
    return self.recv_getAllFbaListedItems()
3801 
 
3802 
  def send_getAllFbaListedItems(self, ):
3803 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3804 
    args = getAllFbaListedItems_args()
3805 
    args.write(self._oprot)
3806 
    self._oprot.writeMessageEnd()
3807 
    self._oprot.trans.flush()
3808 
 
3809 
  def recv_getAllFbaListedItems(self, ):
3810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3811 
    if mtype == TMessageType.EXCEPTION:
3812 
      x = TApplicationException()
3813 
      x.read(self._iprot)
3814 
      self._iprot.readMessageEnd()
3815 
      raise x
3816 
    result = getAllFbaListedItems_result()
3817 
    result.read(self._iprot)
3818 
    self._iprot.readMessageEnd()
3819 
    if result.success is not None:
3820 
      return result.success
3821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3822 
 
3823 
  def getAllNonFbaListedItems(self, ):
3824 
    self.send_getAllNonFbaListedItems()
3825 
    return self.recv_getAllNonFbaListedItems()
3826 
 
3827 
  def send_getAllNonFbaListedItems(self, ):
3828 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3829 
    args = getAllNonFbaListedItems_args()
3830 
    args.write(self._oprot)
3831 
    self._oprot.writeMessageEnd()
3832 
    self._oprot.trans.flush()
3833 
 
3834 
  def recv_getAllNonFbaListedItems(self, ):
3835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3836 
    if mtype == TMessageType.EXCEPTION:
3837 
      x = TApplicationException()
3838 
      x.read(self._iprot)
3839 
      self._iprot.readMessageEnd()
3840 
      raise x
3841 
    result = getAllNonFbaListedItems_result()
3842 
    result.read(self._iprot)
3843 
    self._iprot.readMessageEnd()
3844 
    if result.success is not None:
3845 
      return result.success
3846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3847 
 
7460 kshitij.so 3848 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3849 
    """
3850 
    Parameters:
3851 
     - itemId
3852 
     - holdInventory
3853 
     - defaultInventory
3854 
    """
3855 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3856 
    return self.recv_updateItemInventory()
7291 vikram.rag 3857 
 
7460 kshitij.so 3858 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3859 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3860 
    args = updateItemInventory_args()
3861 
    args.itemId = itemId
3862 
    args.holdInventory = holdInventory
3863 
    args.defaultInventory = defaultInventory
3864 
    args.write(self._oprot)
3865 
    self._oprot.writeMessageEnd()
3866 
    self._oprot.trans.flush()
3867 
 
3868 
  def recv_updateItemInventory(self, ):
3869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3870 
    if mtype == TMessageType.EXCEPTION:
3871 
      x = TApplicationException()
3872 
      x.read(self._iprot)
3873 
      self._iprot.readMessageEnd()
3874 
      raise x
3875 
    result = updateItemInventory_result()
3876 
    result.read(self._iprot)
3877 
    self._iprot.readMessageEnd()
3878 
    if result.success is not None:
3879 
      return result.success
3880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3881 
 
7770 kshitij.so 3882 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3883 
    """
3884 
    Parameters:
3885 
     - type
3886 
     - sku
3887 
     - timestamp
3888 
    """
3889 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3890 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3891 
 
7770 kshitij.so 3892 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3893 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3894 
    args = updateTimestampForAmazonFeeds_args()
3895 
    args.type = type
3896 
    args.sku = sku
3897 
    args.timestamp = timestamp
3898 
    args.write(self._oprot)
3899 
    self._oprot.writeMessageEnd()
3900 
    self._oprot.trans.flush()
3901 
 
3902 
  def recv_updateTimestampForAmazonFeeds(self, ):
3903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3904 
    if mtype == TMessageType.EXCEPTION:
3905 
      x = TApplicationException()
3906 
      x.read(self._iprot)
3907 
      self._iprot.readMessageEnd()
3908 
      raise x
3909 
    result = updateTimestampForAmazonFeeds_result()
3910 
    result.read(self._iprot)
3911 
    self._iprot.readMessageEnd()
3912 
    if result.success is not None:
3913 
      return result.success
3914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3915 
 
7897 amar.kumar 3916 
  def getAllParentCategories(self, ):
3917 
    self.send_getAllParentCategories()
3918 
    return self.recv_getAllParentCategories()
7770 kshitij.so 3919 
 
7897 amar.kumar 3920 
  def send_getAllParentCategories(self, ):
3921 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
3922 
    args = getAllParentCategories_args()
3923 
    args.write(self._oprot)
3924 
    self._oprot.writeMessageEnd()
3925 
    self._oprot.trans.flush()
3926 
 
3927 
  def recv_getAllParentCategories(self, ):
3928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3929 
    if mtype == TMessageType.EXCEPTION:
3930 
      x = TApplicationException()
3931 
      x.read(self._iprot)
3932 
      self._iprot.readMessageEnd()
3933 
      raise x
3934 
    result = getAllParentCategories_result()
3935 
    result.read(self._iprot)
3936 
    self._iprot.readMessageEnd()
3937 
    if result.success is not None:
3938 
      return result.success
3939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
3940 
 
7977 kshitij.so 3941 
  def addPageViewEvent(self, pageViewEvents):
3942 
    """
3943 
    Parameters:
3944 
     - pageViewEvents
3945 
    """
3946 
    self.send_addPageViewEvent(pageViewEvents)
3947 
    self.recv_addPageViewEvent()
7897 amar.kumar 3948 
 
7977 kshitij.so 3949 
  def send_addPageViewEvent(self, pageViewEvents):
3950 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
3951 
    args = addPageViewEvent_args()
3952 
    args.pageViewEvents = pageViewEvents
3953 
    args.write(self._oprot)
3954 
    self._oprot.writeMessageEnd()
3955 
    self._oprot.trans.flush()
3956 
 
3957 
  def recv_addPageViewEvent(self, ):
3958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3959 
    if mtype == TMessageType.EXCEPTION:
3960 
      x = TApplicationException()
3961 
      x.read(self._iprot)
3962 
      self._iprot.readMessageEnd()
3963 
      raise x
3964 
    result = addPageViewEvent_result()
3965 
    result.read(self._iprot)
3966 
    self._iprot.readMessageEnd()
3967 
    return
3968 
 
3969 
  def addCartEvent(self, cartEvents):
3970 
    """
3971 
    Parameters:
3972 
     - cartEvents
3973 
    """
3974 
    self.send_addCartEvent(cartEvents)
3975 
    self.recv_addCartEvent()
3976 
 
3977 
  def send_addCartEvent(self, cartEvents):
3978 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
3979 
    args = addCartEvent_args()
3980 
    args.cartEvents = cartEvents
3981 
    args.write(self._oprot)
3982 
    self._oprot.writeMessageEnd()
3983 
    self._oprot.trans.flush()
3984 
 
3985 
  def recv_addCartEvent(self, ):
3986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3987 
    if mtype == TMessageType.EXCEPTION:
3988 
      x = TApplicationException()
3989 
      x.read(self._iprot)
3990 
      self._iprot.readMessageEnd()
3991 
      raise x
3992 
    result = addCartEvent_result()
3993 
    result.read(self._iprot)
3994 
    self._iprot.readMessageEnd()
3995 
    return
3996 
 
3997 
 
5944 mandeep.dh 3998 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3999 
  def __init__(self, handler):
4000 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4001 
    self._processMap["addItem"] = Processor.process_addItem
4002 
    self._processMap["updateItem"] = Processor.process_updateItem
4003 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4004 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4005 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4006 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4007 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4008 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4009 
    self._processMap["getItem"] = Processor.process_getItem
4010 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4011 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4012 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4013 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4014 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4015 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4016 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4017 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4018 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4019 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4020 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4021 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4022 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4023 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4024 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4025 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4026 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4027 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4028 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4029 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4030 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4031 
    self._processMap["addCategory"] = Processor.process_addCategory
4032 
    self._processMap["getCategory"] = Processor.process_getCategory
4033 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4034 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4035 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4036 
    self._processMap["addTag"] = Processor.process_addTag
4037 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4038 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4039 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4040 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4041 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4042 
    self._processMap["addBanner"] = Processor.process_addBanner
4043 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4044 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4045 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4046 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4047 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
4048 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4049 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 4050 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4051 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4052 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4053 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4054 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4055 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4056 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4057 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4058 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4059 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4060 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4061 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4062 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4063 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4064 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4065 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4066 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4067 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4068 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4069 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4070 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4071 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4072 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4073 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4074 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4075 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4076 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4077 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4078 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4079 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4080 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4081 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4082 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4083 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4084 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4085 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4086 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4087 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4088 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4089 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4090 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4091 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4092 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4093 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4094 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4095 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4096 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4097 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4098 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4099 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4100 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4101 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4102 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
5944 mandeep.dh 4103 
 
4104 
  def process(self, iprot, oprot):
4105 
    (name, type, seqid) = iprot.readMessageBegin()
4106 
    if name not in self._processMap:
4107 
      iprot.skip(TType.STRUCT)
4108 
      iprot.readMessageEnd()
4109 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4110 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4111 
      x.write(oprot)
4112 
      oprot.writeMessageEnd()
4113 
      oprot.trans.flush()
4114 
      return
4115 
    else:
4116 
      self._processMap[name](self, seqid, iprot, oprot)
4117 
    return True
4118 
 
4119 
  def process_addItem(self, seqid, iprot, oprot):
4120 
    args = addItem_args()
4121 
    args.read(iprot)
4122 
    iprot.readMessageEnd()
4123 
    result = addItem_result()
4124 
    try:
4125 
      result.success = self._handler.addItem(args.item)
4126 
    except CatalogServiceException, cex:
4127 
      result.cex = cex
4128 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
4133 
  def process_updateItem(self, seqid, iprot, oprot):
4134 
    args = updateItem_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = updateItem_result()
4138 
    try:
4139 
      result.success = self._handler.updateItem(args.item)
4140 
    except CatalogServiceException, cex:
4141 
      result.cex = cex
4142 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4143 
    result.write(oprot)
4144 
    oprot.writeMessageEnd()
4145 
    oprot.trans.flush()
4146 
 
4147 
  def process_isActive(self, seqid, iprot, oprot):
4148 
    args = isActive_args()
4149 
    args.read(iprot)
4150 
    iprot.readMessageEnd()
4151 
    result = isActive_result()
4152 
    try:
4153 
      result.success = self._handler.isActive(args.itemId)
4154 
    except CatalogServiceException, isex:
4155 
      result.isex = isex
4156 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4157 
    result.write(oprot)
4158 
    oprot.writeMessageEnd()
4159 
    oprot.trans.flush()
4160 
 
7438 amit.gupta 4161 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4162 
    args = getItemsStatus_args()
4163 
    args.read(iprot)
4164 
    iprot.readMessageEnd()
4165 
    result = getItemsStatus_result()
4166 
    try:
4167 
      result.success = self._handler.getItemsStatus(args.itemIds)
4168 
    except CatalogServiceException, isex:
4169 
      result.isex = isex
4170 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4171 
    result.write(oprot)
4172 
    oprot.writeMessageEnd()
4173 
    oprot.trans.flush()
4174 
 
5944 mandeep.dh 4175 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4176 
    args = getItemStatusDescription_args()
4177 
    args.read(iprot)
4178 
    iprot.readMessageEnd()
4179 
    result = getItemStatusDescription_result()
4180 
    try:
4181 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4182 
    except CatalogServiceException, isex:
4183 
      result.isex = isex
4184 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4185 
    result.write(oprot)
4186 
    oprot.writeMessageEnd()
4187 
    oprot.trans.flush()
4188 
 
4189 
  def process_startItemOn(self, seqid, iprot, oprot):
4190 
    args = startItemOn_args()
4191 
    args.read(iprot)
4192 
    iprot.readMessageEnd()
4193 
    result = startItemOn_result()
4194 
    try:
4195 
      self._handler.startItemOn(args.item_id, args.timestamp)
4196 
    except CatalogServiceException, cex:
4197 
      result.cex = cex
4198 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4199 
    result.write(oprot)
4200 
    oprot.writeMessageEnd()
4201 
    oprot.trans.flush()
4202 
 
4203 
  def process_retireItemOn(self, seqid, iprot, oprot):
4204 
    args = retireItemOn_args()
4205 
    args.read(iprot)
4206 
    iprot.readMessageEnd()
4207 
    result = retireItemOn_result()
4208 
    try:
4209 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4210 
    except CatalogServiceException, cex:
4211 
      result.cex = cex
4212 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4213 
    result.write(oprot)
4214 
    oprot.writeMessageEnd()
4215 
    oprot.trans.flush()
4216 
 
4217 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4218 
    args = changeItemStatus_args()
4219 
    args.read(iprot)
4220 
    iprot.readMessageEnd()
4221 
    result = changeItemStatus_result()
4222 
    try:
4223 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4224 
    except CatalogServiceException, cex:
4225 
      result.cex = cex
4226 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4227 
    result.write(oprot)
4228 
    oprot.writeMessageEnd()
4229 
    oprot.trans.flush()
4230 
 
4231 
  def process_getItem(self, seqid, iprot, oprot):
4232 
    args = getItem_args()
4233 
    args.read(iprot)
4234 
    iprot.readMessageEnd()
4235 
    result = getItem_result()
4236 
    try:
4237 
      result.success = self._handler.getItem(args.item_id)
4238 
    except CatalogServiceException, cex:
4239 
      result.cex = cex
4240 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4241 
    result.write(oprot)
4242 
    oprot.writeMessageEnd()
4243 
    oprot.trans.flush()
4244 
 
4245 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4246 
    args = getItemsByCatalogId_args()
4247 
    args.read(iprot)
4248 
    iprot.readMessageEnd()
4249 
    result = getItemsByCatalogId_result()
4250 
    try:
4251 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4252 
    except CatalogServiceException, cex:
4253 
      result.cex = cex
4254 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4255 
    result.write(oprot)
4256 
    oprot.writeMessageEnd()
4257 
    oprot.trans.flush()
4258 
 
4259 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4260 
    args = getValidItemsByCatalogId_args()
4261 
    args.read(iprot)
4262 
    iprot.readMessageEnd()
4263 
    result = getValidItemsByCatalogId_result()
4264 
    try:
4265 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4266 
    except CatalogServiceException, cex:
4267 
      result.cex = cex
4268 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4269 
    result.write(oprot)
4270 
    oprot.writeMessageEnd()
4271 
    oprot.trans.flush()
4272 
 
4273 
  def process_getAllItems(self, seqid, iprot, oprot):
4274 
    args = getAllItems_args()
4275 
    args.read(iprot)
4276 
    iprot.readMessageEnd()
4277 
    result = getAllItems_result()
4278 
    try:
4279 
      result.success = self._handler.getAllItems(args.isActive)
4280 
    except CatalogServiceException, cex:
4281 
      result.cex = cex
4282 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4283 
    result.write(oprot)
4284 
    oprot.writeMessageEnd()
4285 
    oprot.trans.flush()
4286 
 
4287 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4288 
    args = getAllItemsByStatus_args()
4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
4291 
    result = getAllItemsByStatus_result()
4292 
    try:
4293 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4294 
    except CatalogServiceException, cex:
4295 
      result.cex = cex
4296 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
4300 
 
4301 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4302 
    args = markItemAsContentComplete_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    result = markItemAsContentComplete_result()
4306 
    try:
4307 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4308 
    except CatalogServiceException, cex:
4309 
      result.cex = cex
4310 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4311 
    result.write(oprot)
4312 
    oprot.writeMessageEnd()
4313 
    oprot.trans.flush()
4314 
 
4315 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4316 
    args = getAllItemsInRange_args()
4317 
    args.read(iprot)
4318 
    iprot.readMessageEnd()
4319 
    result = getAllItemsInRange_result()
4320 
    try:
4321 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4322 
    except CatalogServiceException, cex:
4323 
      result.cex = cex
4324 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4325 
    result.write(oprot)
4326 
    oprot.writeMessageEnd()
4327 
    oprot.trans.flush()
4328 
 
4329 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4330 
    args = getAllItemsByStatusInRange_args()
4331 
    args.read(iprot)
4332 
    iprot.readMessageEnd()
4333 
    result = getAllItemsByStatusInRange_result()
4334 
    try:
4335 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4336 
    except CatalogServiceException, cex:
4337 
      result.cex = cex
4338 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4342 
 
4343 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4344 
    args = getItemCountByStatus_args()
4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
4347 
    result = getItemCountByStatus_result()
4348 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4349 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4350 
    result.write(oprot)
4351 
    oprot.writeMessageEnd()
4352 
    oprot.trans.flush()
4353 
 
4354 
  def process_getBestSellers(self, seqid, iprot, oprot):
4355 
    args = getBestSellers_args()
4356 
    args.read(iprot)
4357 
    iprot.readMessageEnd()
4358 
    result = getBestSellers_result()
4359 
    try:
4360 
      result.success = self._handler.getBestSellers()
4361 
    except CatalogServiceException, isex:
4362 
      result.isex = isex
4363 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4364 
    result.write(oprot)
4365 
    oprot.writeMessageEnd()
4366 
    oprot.trans.flush()
4367 
 
4368 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4369 
    args = getBestSellersCatalogIds_args()
4370 
    args.read(iprot)
4371 
    iprot.readMessageEnd()
4372 
    result = getBestSellersCatalogIds_result()
4373 
    try:
4374 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4375 
    except CatalogServiceException, cex:
4376 
      result.cex = cex
4377 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4378 
    result.write(oprot)
4379 
    oprot.writeMessageEnd()
4380 
    oprot.trans.flush()
4381 
 
4382 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4383 
    args = getBestSellersCount_args()
4384 
    args.read(iprot)
4385 
    iprot.readMessageEnd()
4386 
    result = getBestSellersCount_result()
4387 
    try:
4388 
      result.success = self._handler.getBestSellersCount()
4389 
    except CatalogServiceException, cex:
4390 
      result.cex = cex
4391 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4392 
    result.write(oprot)
4393 
    oprot.writeMessageEnd()
4394 
    oprot.trans.flush()
4395 
 
4396 
  def process_getBestDeals(self, seqid, iprot, oprot):
4397 
    args = getBestDeals_args()
4398 
    args.read(iprot)
4399 
    iprot.readMessageEnd()
4400 
    result = getBestDeals_result()
4401 
    try:
4402 
      result.success = self._handler.getBestDeals()
4403 
    except CatalogServiceException, isex:
4404 
      result.isex = isex
4405 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4406 
    result.write(oprot)
4407 
    oprot.writeMessageEnd()
4408 
    oprot.trans.flush()
4409 
 
4410 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4411 
    args = getBestDealsCatalogIds_args()
4412 
    args.read(iprot)
4413 
    iprot.readMessageEnd()
4414 
    result = getBestDealsCatalogIds_result()
4415 
    try:
4416 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4417 
    except CatalogServiceException, cex:
4418 
      result.cex = cex
4419 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4420 
    result.write(oprot)
4421 
    oprot.writeMessageEnd()
4422 
    oprot.trans.flush()
4423 
 
4424 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4425 
    args = getBestDealsCount_args()
4426 
    args.read(iprot)
4427 
    iprot.readMessageEnd()
4428 
    result = getBestDealsCount_result()
4429 
    try:
4430 
      result.success = self._handler.getBestDealsCount()
4431 
    except CatalogServiceException, cex:
4432 
      result.cex = cex
4433 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4434 
    result.write(oprot)
4435 
    oprot.writeMessageEnd()
4436 
    oprot.trans.flush()
4437 
 
4438 
  def process_getComingSoon(self, seqid, iprot, oprot):
4439 
    args = getComingSoon_args()
4440 
    args.read(iprot)
4441 
    iprot.readMessageEnd()
4442 
    result = getComingSoon_result()
4443 
    try:
4444 
      result.success = self._handler.getComingSoon()
4445 
    except CatalogServiceException, isex:
4446 
      result.isex = isex
4447 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4448 
    result.write(oprot)
4449 
    oprot.writeMessageEnd()
4450 
    oprot.trans.flush()
4451 
 
4452 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4453 
    args = getComingSoonCatalogIds_args()
4454 
    args.read(iprot)
4455 
    iprot.readMessageEnd()
4456 
    result = getComingSoonCatalogIds_result()
4457 
    try:
4458 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4459 
    except CatalogServiceException, cex:
4460 
      result.cex = cex
4461 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4462 
    result.write(oprot)
4463 
    oprot.writeMessageEnd()
4464 
    oprot.trans.flush()
4465 
 
4466 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4467 
    args = getComingSoonCount_args()
4468 
    args.read(iprot)
4469 
    iprot.readMessageEnd()
4470 
    result = getComingSoonCount_result()
4471 
    try:
4472 
      result.success = self._handler.getComingSoonCount()
4473 
    except CatalogServiceException, cex:
4474 
      result.cex = cex
4475 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4476 
    result.write(oprot)
4477 
    oprot.writeMessageEnd()
4478 
    oprot.trans.flush()
4479 
 
4480 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4481 
    args = getLatestArrivals_args()
4482 
    args.read(iprot)
4483 
    iprot.readMessageEnd()
4484 
    result = getLatestArrivals_result()
4485 
    try:
4486 
      result.success = self._handler.getLatestArrivals()
4487 
    except CatalogServiceException, isex:
4488 
      result.isex = isex
4489 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4490 
    result.write(oprot)
4491 
    oprot.writeMessageEnd()
4492 
    oprot.trans.flush()
4493 
 
4494 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4495 
    args = getLatestArrivalsCatalogIds_args()
4496 
    args.read(iprot)
4497 
    iprot.readMessageEnd()
4498 
    result = getLatestArrivalsCatalogIds_result()
4499 
    try:
4500 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4501 
    except CatalogServiceException, cex:
4502 
      result.cex = cex
4503 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4504 
    result.write(oprot)
4505 
    oprot.writeMessageEnd()
4506 
    oprot.trans.flush()
4507 
 
4508 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4509 
    args = getLatestArrivalsCount_args()
4510 
    args.read(iprot)
4511 
    iprot.readMessageEnd()
4512 
    result = getLatestArrivalsCount_result()
4513 
    try:
4514 
      result.success = self._handler.getLatestArrivalsCount()
4515 
    except CatalogServiceException, cex:
4516 
      result.cex = cex
4517 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4518 
    result.write(oprot)
4519 
    oprot.writeMessageEnd()
4520 
    oprot.trans.flush()
4521 
 
4522 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4523 
    args = generateNewEntityID_args()
4524 
    args.read(iprot)
4525 
    iprot.readMessageEnd()
4526 
    result = generateNewEntityID_result()
4527 
    result.success = self._handler.generateNewEntityID()
4528 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4529 
    result.write(oprot)
4530 
    oprot.writeMessageEnd()
4531 
    oprot.trans.flush()
4532 
 
4533 
  def process_addCategory(self, seqid, iprot, oprot):
4534 
    args = addCategory_args()
4535 
    args.read(iprot)
4536 
    iprot.readMessageEnd()
4537 
    result = addCategory_result()
4538 
    result.success = self._handler.addCategory(args.category)
4539 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4540 
    result.write(oprot)
4541 
    oprot.writeMessageEnd()
4542 
    oprot.trans.flush()
4543 
 
4544 
  def process_getCategory(self, seqid, iprot, oprot):
4545 
    args = getCategory_args()
4546 
    args.read(iprot)
4547 
    iprot.readMessageEnd()
4548 
    result = getCategory_result()
4549 
    result.success = self._handler.getCategory(args.id)
4550 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4551 
    result.write(oprot)
4552 
    oprot.writeMessageEnd()
4553 
    oprot.trans.flush()
4554 
 
4555 
  def process_getAllCategories(self, seqid, iprot, oprot):
4556 
    args = getAllCategories_args()
4557 
    args.read(iprot)
4558 
    iprot.readMessageEnd()
4559 
    result = getAllCategories_result()
4560 
    result.success = self._handler.getAllCategories()
4561 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
4565 
 
4566 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4567 
    args = getAllSimilarItems_args()
4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
4570 
    result = getAllSimilarItems_result()
4571 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4572 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4573 
    result.write(oprot)
4574 
    oprot.writeMessageEnd()
4575 
    oprot.trans.flush()
4576 
 
4577 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4578 
    args = addSimilarItem_args()
4579 
    args.read(iprot)
4580 
    iprot.readMessageEnd()
4581 
    result = addSimilarItem_result()
4582 
    try:
4583 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4584 
    except CatalogServiceException, cex:
4585 
      result.cex = cex
4586 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4587 
    result.write(oprot)
4588 
    oprot.writeMessageEnd()
4589 
    oprot.trans.flush()
4590 
 
6512 kshitij.so 4591 
  def process_addTag(self, seqid, iprot, oprot):
4592 
    args = addTag_args()
4593 
    args.read(iprot)
4594 
    iprot.readMessageEnd()
4595 
    result = addTag_result()
4596 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4597 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4598 
    result.write(oprot)
4599 
    oprot.writeMessageEnd()
4600 
    oprot.trans.flush()
4601 
 
4602 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4603 
    args = deleteEntityTag_args()
4604 
    args.read(iprot)
4605 
    iprot.readMessageEnd()
4606 
    result = deleteEntityTag_result()
4607 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4608 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
4612 
 
4613 
  def process_deleteTag(self, seqid, iprot, oprot):
4614 
    args = deleteTag_args()
4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
4617 
    result = deleteTag_result()
4618 
    result.success = self._handler.deleteTag(args.displayName)
4619 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4620 
    result.write(oprot)
4621 
    oprot.writeMessageEnd()
4622 
    oprot.trans.flush()
4623 
 
4624 
  def process_getAllTags(self, seqid, iprot, oprot):
4625 
    args = getAllTags_args()
4626 
    args.read(iprot)
4627 
    iprot.readMessageEnd()
4628 
    result = getAllTags_result()
4629 
    result.success = self._handler.getAllTags()
4630 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4631 
    result.write(oprot)
4632 
    oprot.writeMessageEnd()
4633 
    oprot.trans.flush()
4634 
 
4635 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4636 
    args = getAllEntitiesByTagName_args()
4637 
    args.read(iprot)
4638 
    iprot.readMessageEnd()
4639 
    result = getAllEntitiesByTagName_result()
4640 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4641 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4642 
    result.write(oprot)
4643 
    oprot.writeMessageEnd()
4644 
    oprot.trans.flush()
4645 
 
6845 amit.gupta 4646 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4647 
    args = getAllEntityTags_args()
4648 
    args.read(iprot)
4649 
    iprot.readMessageEnd()
4650 
    result = getAllEntityTags_result()
4651 
    result.success = self._handler.getAllEntityTags()
4652 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4653 
    result.write(oprot)
4654 
    oprot.writeMessageEnd()
4655 
    oprot.trans.flush()
4656 
 
6850 kshitij.so 4657 
  def process_addBanner(self, seqid, iprot, oprot):
4658 
    args = addBanner_args()
4659 
    args.read(iprot)
4660 
    iprot.readMessageEnd()
4661 
    result = addBanner_result()
4662 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4663 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4664 
    result.write(oprot)
4665 
    oprot.writeMessageEnd()
4666 
    oprot.trans.flush()
4667 
 
4668 
  def process_getAllBanners(self, seqid, iprot, oprot):
4669 
    args = getAllBanners_args()
4670 
    args.read(iprot)
4671 
    iprot.readMessageEnd()
4672 
    result = getAllBanners_result()
4673 
    result.success = self._handler.getAllBanners()
4674 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4675 
    result.write(oprot)
4676 
    oprot.writeMessageEnd()
4677 
    oprot.trans.flush()
4678 
 
4679 
  def process_deleteBanner(self, seqid, iprot, oprot):
4680 
    args = deleteBanner_args()
4681 
    args.read(iprot)
4682 
    iprot.readMessageEnd()
4683 
    result = deleteBanner_result()
4684 
    result.success = self._handler.deleteBanner(args.bannerName)
4685 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4686 
    result.write(oprot)
4687 
    oprot.writeMessageEnd()
4688 
    oprot.trans.flush()
4689 
 
4690 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4691 
    args = getBannerDetails_args()
4692 
    args.read(iprot)
4693 
    iprot.readMessageEnd()
4694 
    result = getBannerDetails_result()
4695 
    result.success = self._handler.getBannerDetails(args.bannerName)
4696 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4697 
    result.write(oprot)
4698 
    oprot.writeMessageEnd()
4699 
    oprot.trans.flush()
4700 
 
4701 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4702 
    args = getActiveBanners_args()
4703 
    args.read(iprot)
4704 
    iprot.readMessageEnd()
4705 
    result = getActiveBanners_result()
4706 
    result.success = self._handler.getActiveBanners()
4707 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4708 
    result.write(oprot)
4709 
    oprot.writeMessageEnd()
4710 
    oprot.trans.flush()
4711 
 
6849 kshitij.so 4712 
  def process_addBannerMap(self, seqid, iprot, oprot):
4713 
    args = addBannerMap_args()
4714 
    args.read(iprot)
4715 
    iprot.readMessageEnd()
4716 
    result = addBannerMap_result()
4717 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4718 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4719 
    result.write(oprot)
4720 
    oprot.writeMessageEnd()
4721 
    oprot.trans.flush()
4722 
 
4723 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4724 
    args = deleteBannerMap_args()
4725 
    args.read(iprot)
4726 
    iprot.readMessageEnd()
4727 
    result = deleteBannerMap_result()
4728 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4729 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
4734 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4735 
    args = getBannerMapDetails_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = getBannerMapDetails_result()
4739 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4740 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4741 
    result.write(oprot)
4742 
    oprot.writeMessageEnd()
4743 
    oprot.trans.flush()
4744 
 
5944 mandeep.dh 4745 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4746 
    args = deleteSimilarItem_args()
4747 
    args.read(iprot)
4748 
    iprot.readMessageEnd()
4749 
    result = deleteSimilarItem_result()
4750 
    try:
4751 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4752 
    except CatalogServiceException, cex:
4753 
      result.cex = cex
4754 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
4759 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4760 
    args = checkSimilarItem_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = checkSimilarItem_result()
4764 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4765 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
4770 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4771 
    args = validateRiskyStatus_args()
4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
4774 
    result = validateRiskyStatus_result()
4775 
    self._handler.validateRiskyStatus(args.itemId)
4776 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4777 
    result.write(oprot)
4778 
    oprot.writeMessageEnd()
4779 
    oprot.trans.flush()
4780 
 
4781 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4782 
    args = changeItemRiskyFlag_args()
4783 
    args.read(iprot)
4784 
    iprot.readMessageEnd()
4785 
    result = changeItemRiskyFlag_result()
4786 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4787 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
4792 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4793 
    args = getItemsByRiskyFlag_args()
4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
4796 
    result = getItemsByRiskyFlag_result()
4797 
    result.success = self._handler.getItemsByRiskyFlag()
4798 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
4803 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4804 
    args = getItemsForMasterSheet_args()
4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
4807 
    result = getItemsForMasterSheet_result()
4808 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4809 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4810 
    result.write(oprot)
4811 
    oprot.writeMessageEnd()
4812 
    oprot.trans.flush()
4813 
 
4814 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4815 
    args = getSimilarItemsCatalogIds_args()
4816 
    args.read(iprot)
4817 
    iprot.readMessageEnd()
4818 
    result = getSimilarItemsCatalogIds_result()
4819 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4820 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4821 
    result.write(oprot)
4822 
    oprot.writeMessageEnd()
4823 
    oprot.trans.flush()
4824 
 
4825 
  def process_addProductNotification(self, seqid, iprot, oprot):
4826 
    args = addProductNotification_args()
4827 
    args.read(iprot)
4828 
    iprot.readMessageEnd()
4829 
    result = addProductNotification_result()
4830 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4831 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4832 
    result.write(oprot)
4833 
    oprot.writeMessageEnd()
4834 
    oprot.trans.flush()
4835 
 
4836 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4837 
    args = sendProductNotifications_args()
4838 
    args.read(iprot)
4839 
    iprot.readMessageEnd()
4840 
    result = sendProductNotifications_result()
4841 
    result.success = self._handler.sendProductNotifications()
4842 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4843 
    result.write(oprot)
4844 
    oprot.writeMessageEnd()
4845 
    oprot.trans.flush()
4846 
 
4847 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4848 
    args = getAllBrandsByCategory_args()
4849 
    args.read(iprot)
4850 
    iprot.readMessageEnd()
4851 
    result = getAllBrandsByCategory_result()
4852 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4853 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4854 
    result.write(oprot)
4855 
    oprot.writeMessageEnd()
4856 
    oprot.trans.flush()
4857 
 
4858 
  def process_getAllBrands(self, seqid, iprot, oprot):
4859 
    args = getAllBrands_args()
4860 
    args.read(iprot)
4861 
    iprot.readMessageEnd()
4862 
    result = getAllBrands_result()
4863 
    result.success = self._handler.getAllBrands()
4864 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4865 
    result.write(oprot)
4866 
    oprot.writeMessageEnd()
4867 
    oprot.trans.flush()
4868 
 
4869 
  def process_getAllSources(self, seqid, iprot, oprot):
4870 
    args = getAllSources_args()
4871 
    args.read(iprot)
4872 
    iprot.readMessageEnd()
4873 
    result = getAllSources_result()
4874 
    result.success = self._handler.getAllSources()
4875 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4876 
    result.write(oprot)
4877 
    oprot.writeMessageEnd()
4878 
    oprot.trans.flush()
4879 
 
4880 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4881 
    args = getItemPricingBySource_args()
4882 
    args.read(iprot)
4883 
    iprot.readMessageEnd()
4884 
    result = getItemPricingBySource_result()
4885 
    try:
4886 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4887 
    except CatalogServiceException, cex:
4888 
      result.cex = cex
4889 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
4893 
 
4894 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4895 
    args = addSourceItemPricing_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = addSourceItemPricing_result()
4899 
    try:
4900 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4901 
    except CatalogServiceException, cex:
4902 
      result.cex = cex
4903 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4904 
    result.write(oprot)
4905 
    oprot.writeMessageEnd()
4906 
    oprot.trans.flush()
4907 
 
4908 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4909 
    args = getAllSourcePricing_args()
4910 
    args.read(iprot)
4911 
    iprot.readMessageEnd()
4912 
    result = getAllSourcePricing_result()
4913 
    try:
4914 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4915 
    except CatalogServiceException, cex:
4916 
      result.cex = cex
4917 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4918 
    result.write(oprot)
4919 
    oprot.writeMessageEnd()
4920 
    oprot.trans.flush()
4921 
 
4922 
  def process_getItemForSource(self, seqid, iprot, oprot):
4923 
    args = getItemForSource_args()
4924 
    args.read(iprot)
4925 
    iprot.readMessageEnd()
4926 
    result = getItemForSource_result()
4927 
    try:
4928 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4929 
    except CatalogServiceException, cex:
4930 
      result.cex = cex
4931 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4932 
    result.write(oprot)
4933 
    oprot.writeMessageEnd()
4934 
    oprot.trans.flush()
4935 
 
4936 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4937 
    args = searchItemsInRange_args()
4938 
    args.read(iprot)
4939 
    iprot.readMessageEnd()
4940 
    result = searchItemsInRange_result()
4941 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4942 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4943 
    result.write(oprot)
4944 
    oprot.writeMessageEnd()
4945 
    oprot.trans.flush()
4946 
 
4947 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4948 
    args = getSearchResultCount_args()
4949 
    args.read(iprot)
4950 
    iprot.readMessageEnd()
4951 
    result = getSearchResultCount_result()
4952 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4953 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4954 
    result.write(oprot)
4955 
    oprot.writeMessageEnd()
4956 
    oprot.trans.flush()
4957 
 
4958 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4959 
    args = getProductNotifications_args()
4960 
    args.read(iprot)
4961 
    iprot.readMessageEnd()
4962 
    result = getProductNotifications_result()
4963 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4964 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4965 
    result.write(oprot)
4966 
    oprot.writeMessageEnd()
4967 
    oprot.trans.flush()
4968 
 
4969 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4970 
    args = getProductNotificationRequestCount_args()
4971 
    args.read(iprot)
4972 
    iprot.readMessageEnd()
4973 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 4974 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 4975 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
4979 
 
4980 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4981 
    args = addAuthorizationLog_args()
4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
4984 
    result = addAuthorizationLog_result()
4985 
    try:
4986 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4987 
    except CatalogServiceException, cex:
4988 
      result.cex = cex
4989 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4990 
    result.write(oprot)
4991 
    oprot.writeMessageEnd()
4992 
    oprot.trans.flush()
4993 
 
4994 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4995 
    args = addupdateVoucherForItem_args()
4996 
    args.read(iprot)
4997 
    iprot.readMessageEnd()
4998 
    result = addupdateVoucherForItem_result()
4999 
    try:
5000 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5001 
    except CatalogServiceException, cex:
5002 
      result.cex = cex
5003 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
5007 
 
5008 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5009 
    args = deleteVoucherForItem_args()
5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
5012 
    result = deleteVoucherForItem_result()
5013 
    try:
5014 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5015 
    except CatalogServiceException, cex:
5016 
      result.cex = cex
5017 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5018 
    result.write(oprot)
5019 
    oprot.writeMessageEnd()
5020 
    oprot.trans.flush()
5021 
 
5022 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5023 
    args = getVoucherAmount_args()
5024 
    args.read(iprot)
5025 
    iprot.readMessageEnd()
5026 
    result = getVoucherAmount_result()
5027 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5028 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5029 
    result.write(oprot)
5030 
    oprot.writeMessageEnd()
5031 
    oprot.trans.flush()
5032 
 
5033 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5034 
    args = getAllItemVouchers_args()
5035 
    args.read(iprot)
5036 
    iprot.readMessageEnd()
5037 
    result = getAllItemVouchers_result()
5038 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5039 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5040 
    result.write(oprot)
5041 
    oprot.writeMessageEnd()
5042 
    oprot.trans.flush()
5043 
 
5044 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5045 
    args = isValidCatalogItemId_args()
5046 
    args.read(iprot)
5047 
    iprot.readMessageEnd()
5048 
    result = isValidCatalogItemId_result()
5049 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5050 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5051 
    result.write(oprot)
5052 
    oprot.writeMessageEnd()
5053 
    oprot.trans.flush()
5054 
 
6039 amit.gupta 5055 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5056 
    args = getVatPercentageForItem_args()
5057 
    args.read(iprot)
5058 
    iprot.readMessageEnd()
5059 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5060 
    try:
5061 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5062 
    except CatalogServiceException, cex:
5063 
      result.cex = cex
6039 amit.gupta 5064 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5065 
    result.write(oprot)
5066 
    oprot.writeMessageEnd()
5067 
    oprot.trans.flush()
5944 mandeep.dh 5068 
 
6039 amit.gupta 5069 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5070 
    args = getVatAmountForItem_args()
5071 
    args.read(iprot)
5072 
    iprot.readMessageEnd()
5073 
    result = getVatAmountForItem_result()
5074 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5075 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
5079 
 
6531 vikram.rag 5080 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5081 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5085 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5086 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
6039 amit.gupta 5090 
 
6821 amar.kumar 5091 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5092 
    args = getAllAliveItems_args()
5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
5095 
    result = getAllAliveItems_result()
5096 
    result.success = self._handler.getAllAliveItems()
5097 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
5101 
 
6805 anupam.sin 5102 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5103 
    args = getInsuranceAmount_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = getInsuranceAmount_result()
6921 anupam.sin 5107 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5108 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5109 
    result.write(oprot)
5110 
    oprot.writeMessageEnd()
5111 
    oprot.trans.flush()
6531 vikram.rag 5112 
 
6805 anupam.sin 5113 
  def process_getInsurer(self, seqid, iprot, oprot):
5114 
    args = getInsurer_args()
5115 
    args.read(iprot)
5116 
    iprot.readMessageEnd()
5117 
    result = getInsurer_result()
5118 
    result.success = self._handler.getInsurer(args.insurerId)
5119 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5120 
    result.write(oprot)
5121 
    oprot.writeMessageEnd()
5122 
    oprot.trans.flush()
5123 
 
6838 vikram.rag 5124 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5125 
    args = getAllInsurers_args()
5126 
    args.read(iprot)
5127 
    iprot.readMessageEnd()
5128 
    result = getAllInsurers_result()
5129 
    result.success = self._handler.getAllInsurers()
5130 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5131 
    result.write(oprot)
5132 
    oprot.writeMessageEnd()
5133 
    oprot.trans.flush()
6805 anupam.sin 5134 
 
6962 rajveer 5135 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5136 
    args = updateInsuranceDeclaredAmount_args()
5137 
    args.read(iprot)
5138 
    iprot.readMessageEnd()
5139 
    result = updateInsuranceDeclaredAmount_result()
5140 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5141 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5142 
    result.write(oprot)
5143 
    oprot.writeMessageEnd()
5144 
    oprot.trans.flush()
6838 vikram.rag 5145 
 
7190 amar.kumar 5146 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5147 
    args = getFreebieForItem_args()
5148 
    args.read(iprot)
5149 
    iprot.readMessageEnd()
5150 
    result = getFreebieForItem_result()
5151 
    result.success = self._handler.getFreebieForItem(args.itemId)
5152 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5153 
    result.write(oprot)
5154 
    oprot.writeMessageEnd()
5155 
    oprot.trans.flush()
6962 rajveer 5156 
 
7190 amar.kumar 5157 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5158 
    args = addOrUpdateFreebieForItem_args()
5159 
    args.read(iprot)
5160 
    iprot.readMessageEnd()
5161 
    result = addOrUpdateFreebieForItem_result()
5162 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5163 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5164 
    result.write(oprot)
5165 
    oprot.writeMessageEnd()
5166 
    oprot.trans.flush()
5167 
 
7272 amit.gupta 5168 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5169 
    args = addOrUpdateBrandInfo_args()
5170 
    args.read(iprot)
5171 
    iprot.readMessageEnd()
5172 
    result = addOrUpdateBrandInfo_result()
5173 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5174 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5175 
    result.write(oprot)
5176 
    oprot.writeMessageEnd()
5177 
    oprot.trans.flush()
5178 
 
5179 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5180 
    args = getBrandInfo_args()
5181 
    args.read(iprot)
5182 
    iprot.readMessageEnd()
5183 
    result = getBrandInfo_result()
5184 
    result.success = self._handler.getBrandInfo()
5185 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5186 
    result.write(oprot)
5187 
    oprot.writeMessageEnd()
5188 
    oprot.trans.flush()
5189 
 
7256 rajveer 5190 
  def process_getStorePricing(self, seqid, iprot, oprot):
5191 
    args = getStorePricing_args()
5192 
    args.read(iprot)
5193 
    iprot.readMessageEnd()
5194 
    result = getStorePricing_result()
5195 
    result.success = self._handler.getStorePricing(args.itemId)
5196 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5197 
    result.write(oprot)
5198 
    oprot.writeMessageEnd()
5199 
    oprot.trans.flush()
7190 amar.kumar 5200 
 
7306 rajveer 5201 
  def process_getStorePricings(self, seqid, iprot, oprot):
5202 
    args = getStorePricings_args()
5203 
    args.read(iprot)
5204 
    iprot.readMessageEnd()
5205 
    result = getStorePricings_result()
5206 
    result.success = self._handler.getStorePricings(args.itemIds)
5207 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5208 
    result.write(oprot)
5209 
    oprot.writeMessageEnd()
5210 
    oprot.trans.flush()
5211 
 
7265 rajveer 5212 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5213 
    args = updateStorePricing_args()
5214 
    args.read(iprot)
5215 
    iprot.readMessageEnd()
5216 
    result = updateStorePricing_result()
7382 rajveer 5217 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5218 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5219 
    result.write(oprot)
5220 
    oprot.writeMessageEnd()
5221 
    oprot.trans.flush()
7256 rajveer 5222 
 
7281 kshitij.so 5223 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5224 
    args = getAllAmazonListedItems_args()
5225 
    args.read(iprot)
5226 
    iprot.readMessageEnd()
5227 
    result = getAllAmazonListedItems_result()
5228 
    result.success = self._handler.getAllAmazonListedItems()
5229 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5230 
    result.write(oprot)
5231 
    oprot.writeMessageEnd()
5232 
    oprot.trans.flush()
7265 rajveer 5233 
 
7281 kshitij.so 5234 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5235 
    args = getAmazonItemDetails_args()
5236 
    args.read(iprot)
5237 
    iprot.readMessageEnd()
5238 
    result = getAmazonItemDetails_result()
5239 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5240 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5241 
    result.write(oprot)
5242 
    oprot.writeMessageEnd()
5243 
    oprot.trans.flush()
5244 
 
5245 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5246 
    args = updateAmazonItemDetails_args()
5247 
    args.read(iprot)
5248 
    iprot.readMessageEnd()
5249 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5250 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5251 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5252 
    result.write(oprot)
5253 
    oprot.writeMessageEnd()
5254 
    oprot.trans.flush()
5255 
 
5256 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5257 
    args = addAmazonItem_args()
5258 
    args.read(iprot)
5259 
    iprot.readMessageEnd()
5260 
    result = addAmazonItem_result()
5261 
    self._handler.addAmazonItem(args.amazonlisted)
5262 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5263 
    result.write(oprot)
5264 
    oprot.writeMessageEnd()
5265 
    oprot.trans.flush()
5266 
 
7291 vikram.rag 5267 
  def process_getAsinItems(self, seqid, iprot, oprot):
5268 
    args = getAsinItems_args()
5269 
    args.read(iprot)
5270 
    iprot.readMessageEnd()
5271 
    result = getAsinItems_result()
5272 
    result.success = self._handler.getAsinItems()
5273 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5274 
    result.write(oprot)
5275 
    oprot.writeMessageEnd()
5276 
    oprot.trans.flush()
7281 kshitij.so 5277 
 
7291 vikram.rag 5278 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5279 
    args = getAllFbaListedItems_args()
5280 
    args.read(iprot)
5281 
    iprot.readMessageEnd()
5282 
    result = getAllFbaListedItems_result()
5283 
    result.success = self._handler.getAllFbaListedItems()
5284 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5285 
    result.write(oprot)
5286 
    oprot.writeMessageEnd()
5287 
    oprot.trans.flush()
5288 
 
5289 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5290 
    args = getAllNonFbaListedItems_args()
5291 
    args.read(iprot)
5292 
    iprot.readMessageEnd()
5293 
    result = getAllNonFbaListedItems_result()
5294 
    result.success = self._handler.getAllNonFbaListedItems()
5295 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5296 
    result.write(oprot)
5297 
    oprot.writeMessageEnd()
5298 
    oprot.trans.flush()
5299 
 
7460 kshitij.so 5300 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5301 
    args = updateItemInventory_args()
5302 
    args.read(iprot)
5303 
    iprot.readMessageEnd()
5304 
    result = updateItemInventory_result()
5305 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5306 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5307 
    result.write(oprot)
5308 
    oprot.writeMessageEnd()
5309 
    oprot.trans.flush()
7291 vikram.rag 5310 
 
7770 kshitij.so 5311 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5312 
    args = updateTimestampForAmazonFeeds_args()
5313 
    args.read(iprot)
5314 
    iprot.readMessageEnd()
5315 
    result = updateTimestampForAmazonFeeds_result()
5316 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5317 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5318 
    result.write(oprot)
5319 
    oprot.writeMessageEnd()
5320 
    oprot.trans.flush()
7460 kshitij.so 5321 
 
7897 amar.kumar 5322 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5323 
    args = getAllParentCategories_args()
5324 
    args.read(iprot)
5325 
    iprot.readMessageEnd()
5326 
    result = getAllParentCategories_result()
5327 
    result.success = self._handler.getAllParentCategories()
5328 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5329 
    result.write(oprot)
5330 
    oprot.writeMessageEnd()
5331 
    oprot.trans.flush()
7770 kshitij.so 5332 
 
7977 kshitij.so 5333 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5334 
    args = addPageViewEvent_args()
5335 
    args.read(iprot)
5336 
    iprot.readMessageEnd()
5337 
    result = addPageViewEvent_result()
5338 
    self._handler.addPageViewEvent(args.pageViewEvents)
5339 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5340 
    result.write(oprot)
5341 
    oprot.writeMessageEnd()
5342 
    oprot.trans.flush()
7897 amar.kumar 5343 
 
7977 kshitij.so 5344 
  def process_addCartEvent(self, seqid, iprot, oprot):
5345 
    args = addCartEvent_args()
5346 
    args.read(iprot)
5347 
    iprot.readMessageEnd()
5348 
    result = addCartEvent_result()
5349 
    self._handler.addCartEvent(args.cartEvents)
5350 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5351 
    result.write(oprot)
5352 
    oprot.writeMessageEnd()
5353 
    oprot.trans.flush()
5354 
 
5355 
 
5944 mandeep.dh 5356 
# HELPER FUNCTIONS AND STRUCTURES
5357 
 
5358 
class addItem_args:
5359 
  """
5360 
  Attributes:
5361 
   - item
5362 
  """
5363 
 
5364 
  thrift_spec = (
5365 
    None, # 0
5366 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5367 
  )
5368 
 
5369 
  def __init__(self, item=None,):
5370 
    self.item = item
5371 
 
5372 
  def read(self, iprot):
5373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5375 
      return
5376 
    iprot.readStructBegin()
5377 
    while True:
5378 
      (fname, ftype, fid) = iprot.readFieldBegin()
5379 
      if ftype == TType.STOP:
5380 
        break
5381 
      if fid == 1:
5382 
        if ftype == TType.STRUCT:
5383 
          self.item = Item()
5384 
          self.item.read(iprot)
5385 
        else:
5386 
          iprot.skip(ftype)
5387 
      else:
5388 
        iprot.skip(ftype)
5389 
      iprot.readFieldEnd()
5390 
    iprot.readStructEnd()
5391 
 
5392 
  def write(self, oprot):
5393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5395 
      return
5396 
    oprot.writeStructBegin('addItem_args')
5397 
    if self.item is not None:
5398 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5399 
      self.item.write(oprot)
5400 
      oprot.writeFieldEnd()
5401 
    oprot.writeFieldStop()
5402 
    oprot.writeStructEnd()
5403 
 
5404 
  def validate(self):
5405 
    return
5406 
 
5407 
 
5408 
  def __repr__(self):
5409 
    L = ['%s=%r' % (key, value)
5410 
      for key, value in self.__dict__.iteritems()]
5411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5412 
 
5413 
  def __eq__(self, other):
5414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5415 
 
5416 
  def __ne__(self, other):
5417 
    return not (self == other)
5418 
 
5419 
class addItem_result:
5420 
  """
5421 
  Attributes:
5422 
   - success
5423 
   - cex
5424 
  """
5425 
 
5426 
  thrift_spec = (
5427 
    (0, TType.I64, 'success', None, None, ), # 0
5428 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5429 
  )
5430 
 
5431 
  def __init__(self, success=None, cex=None,):
5432 
    self.success = success
5433 
    self.cex = cex
5434 
 
5435 
  def read(self, iprot):
5436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5438 
      return
5439 
    iprot.readStructBegin()
5440 
    while True:
5441 
      (fname, ftype, fid) = iprot.readFieldBegin()
5442 
      if ftype == TType.STOP:
5443 
        break
5444 
      if fid == 0:
5445 
        if ftype == TType.I64:
5446 
          self.success = iprot.readI64();
5447 
        else:
5448 
          iprot.skip(ftype)
5449 
      elif fid == 1:
5450 
        if ftype == TType.STRUCT:
5451 
          self.cex = CatalogServiceException()
5452 
          self.cex.read(iprot)
5453 
        else:
5454 
          iprot.skip(ftype)
5455 
      else:
5456 
        iprot.skip(ftype)
5457 
      iprot.readFieldEnd()
5458 
    iprot.readStructEnd()
5459 
 
5460 
  def write(self, oprot):
5461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5463 
      return
5464 
    oprot.writeStructBegin('addItem_result')
5465 
    if self.success is not None:
5466 
      oprot.writeFieldBegin('success', TType.I64, 0)
5467 
      oprot.writeI64(self.success)
5468 
      oprot.writeFieldEnd()
5469 
    if self.cex is not None:
5470 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5471 
      self.cex.write(oprot)
5472 
      oprot.writeFieldEnd()
5473 
    oprot.writeFieldStop()
5474 
    oprot.writeStructEnd()
5475 
 
5476 
  def validate(self):
5477 
    return
5478 
 
5479 
 
5480 
  def __repr__(self):
5481 
    L = ['%s=%r' % (key, value)
5482 
      for key, value in self.__dict__.iteritems()]
5483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5484 
 
5485 
  def __eq__(self, other):
5486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5487 
 
5488 
  def __ne__(self, other):
5489 
    return not (self == other)
5490 
 
5491 
class updateItem_args:
5492 
  """
5493 
  Attributes:
5494 
   - item
5495 
  """
5496 
 
5497 
  thrift_spec = (
5498 
    None, # 0
5499 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5500 
  )
5501 
 
5502 
  def __init__(self, item=None,):
5503 
    self.item = item
5504 
 
5505 
  def read(self, iprot):
5506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5508 
      return
5509 
    iprot.readStructBegin()
5510 
    while True:
5511 
      (fname, ftype, fid) = iprot.readFieldBegin()
5512 
      if ftype == TType.STOP:
5513 
        break
5514 
      if fid == 1:
5515 
        if ftype == TType.STRUCT:
5516 
          self.item = Item()
5517 
          self.item.read(iprot)
5518 
        else:
5519 
          iprot.skip(ftype)
5520 
      else:
5521 
        iprot.skip(ftype)
5522 
      iprot.readFieldEnd()
5523 
    iprot.readStructEnd()
5524 
 
5525 
  def write(self, oprot):
5526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5528 
      return
5529 
    oprot.writeStructBegin('updateItem_args')
5530 
    if self.item is not None:
5531 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5532 
      self.item.write(oprot)
5533 
      oprot.writeFieldEnd()
5534 
    oprot.writeFieldStop()
5535 
    oprot.writeStructEnd()
5536 
 
5537 
  def validate(self):
5538 
    return
5539 
 
5540 
 
5541 
  def __repr__(self):
5542 
    L = ['%s=%r' % (key, value)
5543 
      for key, value in self.__dict__.iteritems()]
5544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5545 
 
5546 
  def __eq__(self, other):
5547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5548 
 
5549 
  def __ne__(self, other):
5550 
    return not (self == other)
5551 
 
5552 
class updateItem_result:
5553 
  """
5554 
  Attributes:
5555 
   - success
5556 
   - cex
5557 
  """
5558 
 
5559 
  thrift_spec = (
5560 
    (0, TType.I64, 'success', None, None, ), # 0
5561 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5562 
  )
5563 
 
5564 
  def __init__(self, success=None, cex=None,):
5565 
    self.success = success
5566 
    self.cex = cex
5567 
 
5568 
  def read(self, iprot):
5569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5571 
      return
5572 
    iprot.readStructBegin()
5573 
    while True:
5574 
      (fname, ftype, fid) = iprot.readFieldBegin()
5575 
      if ftype == TType.STOP:
5576 
        break
5577 
      if fid == 0:
5578 
        if ftype == TType.I64:
5579 
          self.success = iprot.readI64();
5580 
        else:
5581 
          iprot.skip(ftype)
5582 
      elif fid == 1:
5583 
        if ftype == TType.STRUCT:
5584 
          self.cex = CatalogServiceException()
5585 
          self.cex.read(iprot)
5586 
        else:
5587 
          iprot.skip(ftype)
5588 
      else:
5589 
        iprot.skip(ftype)
5590 
      iprot.readFieldEnd()
5591 
    iprot.readStructEnd()
5592 
 
5593 
  def write(self, oprot):
5594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5596 
      return
5597 
    oprot.writeStructBegin('updateItem_result')
5598 
    if self.success is not None:
5599 
      oprot.writeFieldBegin('success', TType.I64, 0)
5600 
      oprot.writeI64(self.success)
5601 
      oprot.writeFieldEnd()
5602 
    if self.cex is not None:
5603 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5604 
      self.cex.write(oprot)
5605 
      oprot.writeFieldEnd()
5606 
    oprot.writeFieldStop()
5607 
    oprot.writeStructEnd()
5608 
 
5609 
  def validate(self):
5610 
    return
5611 
 
5612 
 
5613 
  def __repr__(self):
5614 
    L = ['%s=%r' % (key, value)
5615 
      for key, value in self.__dict__.iteritems()]
5616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5617 
 
5618 
  def __eq__(self, other):
5619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5620 
 
5621 
  def __ne__(self, other):
5622 
    return not (self == other)
5623 
 
5624 
class isActive_args:
5625 
  """
5626 
  Attributes:
5627 
   - itemId
5628 
  """
5629 
 
5630 
  thrift_spec = (
5631 
    None, # 0
5632 
    (1, TType.I64, 'itemId', None, None, ), # 1
5633 
  )
5634 
 
5635 
  def __init__(self, itemId=None,):
5636 
    self.itemId = itemId
5637 
 
5638 
  def read(self, iprot):
5639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5641 
      return
5642 
    iprot.readStructBegin()
5643 
    while True:
5644 
      (fname, ftype, fid) = iprot.readFieldBegin()
5645 
      if ftype == TType.STOP:
5646 
        break
5647 
      if fid == 1:
5648 
        if ftype == TType.I64:
5649 
          self.itemId = iprot.readI64();
5650 
        else:
5651 
          iprot.skip(ftype)
5652 
      else:
5653 
        iprot.skip(ftype)
5654 
      iprot.readFieldEnd()
5655 
    iprot.readStructEnd()
5656 
 
5657 
  def write(self, oprot):
5658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5660 
      return
5661 
    oprot.writeStructBegin('isActive_args')
5662 
    if self.itemId is not None:
5663 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5664 
      oprot.writeI64(self.itemId)
5665 
      oprot.writeFieldEnd()
5666 
    oprot.writeFieldStop()
5667 
    oprot.writeStructEnd()
5668 
 
5669 
  def validate(self):
5670 
    return
5671 
 
5672 
 
5673 
  def __repr__(self):
5674 
    L = ['%s=%r' % (key, value)
5675 
      for key, value in self.__dict__.iteritems()]
5676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5677 
 
5678 
  def __eq__(self, other):
5679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5680 
 
5681 
  def __ne__(self, other):
5682 
    return not (self == other)
5683 
 
5684 
class isActive_result:
5685 
  """
5686 
  Attributes:
5687 
   - success
5688 
   - isex
5689 
  """
5690 
 
5691 
  thrift_spec = (
5692 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5693 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5694 
  )
5695 
 
5696 
  def __init__(self, success=None, isex=None,):
5697 
    self.success = success
5698 
    self.isex = isex
5699 
 
5700 
  def read(self, iprot):
5701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5703 
      return
5704 
    iprot.readStructBegin()
5705 
    while True:
5706 
      (fname, ftype, fid) = iprot.readFieldBegin()
5707 
      if ftype == TType.STOP:
5708 
        break
5709 
      if fid == 0:
5710 
        if ftype == TType.STRUCT:
5711 
          self.success = ItemShippingInfo()
5712 
          self.success.read(iprot)
5713 
        else:
5714 
          iprot.skip(ftype)
5715 
      elif fid == 1:
5716 
        if ftype == TType.STRUCT:
5717 
          self.isex = CatalogServiceException()
5718 
          self.isex.read(iprot)
5719 
        else:
5720 
          iprot.skip(ftype)
5721 
      else:
5722 
        iprot.skip(ftype)
5723 
      iprot.readFieldEnd()
5724 
    iprot.readStructEnd()
5725 
 
5726 
  def write(self, oprot):
5727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5729 
      return
5730 
    oprot.writeStructBegin('isActive_result')
5731 
    if self.success is not None:
5732 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5733 
      self.success.write(oprot)
5734 
      oprot.writeFieldEnd()
5735 
    if self.isex is not None:
5736 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5737 
      self.isex.write(oprot)
5738 
      oprot.writeFieldEnd()
5739 
    oprot.writeFieldStop()
5740 
    oprot.writeStructEnd()
5741 
 
5742 
  def validate(self):
5743 
    return
5744 
 
5745 
 
5746 
  def __repr__(self):
5747 
    L = ['%s=%r' % (key, value)
5748 
      for key, value in self.__dict__.iteritems()]
5749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5750 
 
5751 
  def __eq__(self, other):
5752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5753 
 
5754 
  def __ne__(self, other):
5755 
    return not (self == other)
5756 
 
7438 amit.gupta 5757 
class getItemsStatus_args:
5758 
  """
5759 
  Attributes:
5760 
   - itemIds
5761 
  """
5762 
 
5763 
  thrift_spec = (
5764 
    None, # 0
5765 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5766 
  )
5767 
 
5768 
  def __init__(self, itemIds=None,):
5769 
    self.itemIds = itemIds
5770 
 
5771 
  def read(self, iprot):
5772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5774 
      return
5775 
    iprot.readStructBegin()
5776 
    while True:
5777 
      (fname, ftype, fid) = iprot.readFieldBegin()
5778 
      if ftype == TType.STOP:
5779 
        break
5780 
      if fid == 1:
5781 
        if ftype == TType.LIST:
5782 
          self.itemIds = []
5783 
          (_etype19, _size16) = iprot.readListBegin()
5784 
          for _i20 in xrange(_size16):
5785 
            _elem21 = iprot.readI64();
5786 
            self.itemIds.append(_elem21)
5787 
          iprot.readListEnd()
5788 
        else:
5789 
          iprot.skip(ftype)
5790 
      else:
5791 
        iprot.skip(ftype)
5792 
      iprot.readFieldEnd()
5793 
    iprot.readStructEnd()
5794 
 
5795 
  def write(self, oprot):
5796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5798 
      return
5799 
    oprot.writeStructBegin('getItemsStatus_args')
5800 
    if self.itemIds is not None:
5801 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5802 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5803 
      for iter22 in self.itemIds:
5804 
        oprot.writeI64(iter22)
5805 
      oprot.writeListEnd()
5806 
      oprot.writeFieldEnd()
5807 
    oprot.writeFieldStop()
5808 
    oprot.writeStructEnd()
5809 
 
5810 
  def validate(self):
5811 
    return
5812 
 
5813 
 
5814 
  def __repr__(self):
5815 
    L = ['%s=%r' % (key, value)
5816 
      for key, value in self.__dict__.iteritems()]
5817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5818 
 
5819 
  def __eq__(self, other):
5820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5821 
 
5822 
  def __ne__(self, other):
5823 
    return not (self == other)
5824 
 
5825 
class getItemsStatus_result:
5826 
  """
5827 
  Attributes:
5828 
   - success
5829 
   - isex
5830 
  """
5831 
 
5832 
  thrift_spec = (
5833 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5834 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5835 
  )
5836 
 
5837 
  def __init__(self, success=None, isex=None,):
5838 
    self.success = success
5839 
    self.isex = isex
5840 
 
5841 
  def read(self, iprot):
5842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5844 
      return
5845 
    iprot.readStructBegin()
5846 
    while True:
5847 
      (fname, ftype, fid) = iprot.readFieldBegin()
5848 
      if ftype == TType.STOP:
5849 
        break
5850 
      if fid == 0:
5851 
        if ftype == TType.MAP:
5852 
          self.success = {}
5853 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5854 
          for _i27 in xrange(_size23):
5855 
            _key28 = iprot.readI64();
5856 
            _val29 = iprot.readBool();
5857 
            self.success[_key28] = _val29
5858 
          iprot.readMapEnd()
5859 
        else:
5860 
          iprot.skip(ftype)
5861 
      elif fid == 1:
5862 
        if ftype == TType.STRUCT:
5863 
          self.isex = CatalogServiceException()
5864 
          self.isex.read(iprot)
5865 
        else:
5866 
          iprot.skip(ftype)
5867 
      else:
5868 
        iprot.skip(ftype)
5869 
      iprot.readFieldEnd()
5870 
    iprot.readStructEnd()
5871 
 
5872 
  def write(self, oprot):
5873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5875 
      return
5876 
    oprot.writeStructBegin('getItemsStatus_result')
5877 
    if self.success is not None:
5878 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5879 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5880 
      for kiter30,viter31 in self.success.items():
5881 
        oprot.writeI64(kiter30)
5882 
        oprot.writeBool(viter31)
5883 
      oprot.writeMapEnd()
5884 
      oprot.writeFieldEnd()
5885 
    if self.isex is not None:
5886 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5887 
      self.isex.write(oprot)
5888 
      oprot.writeFieldEnd()
5889 
    oprot.writeFieldStop()
5890 
    oprot.writeStructEnd()
5891 
 
5892 
  def validate(self):
5893 
    return
5894 
 
5895 
 
5896 
  def __repr__(self):
5897 
    L = ['%s=%r' % (key, value)
5898 
      for key, value in self.__dict__.iteritems()]
5899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5900 
 
5901 
  def __eq__(self, other):
5902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5903 
 
5904 
  def __ne__(self, other):
5905 
    return not (self == other)
5906 
 
5944 mandeep.dh 5907 
class getItemStatusDescription_args:
5908 
  """
5909 
  Attributes:
5910 
   - itemId
5911 
  """
5912 
 
5913 
  thrift_spec = (
5914 
    None, # 0
5915 
    (1, TType.I64, 'itemId', None, None, ), # 1
5916 
  )
5917 
 
5918 
  def __init__(self, itemId=None,):
5919 
    self.itemId = itemId
5920 
 
5921 
  def read(self, iprot):
5922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5924 
      return
5925 
    iprot.readStructBegin()
5926 
    while True:
5927 
      (fname, ftype, fid) = iprot.readFieldBegin()
5928 
      if ftype == TType.STOP:
5929 
        break
5930 
      if fid == 1:
5931 
        if ftype == TType.I64:
5932 
          self.itemId = iprot.readI64();
5933 
        else:
5934 
          iprot.skip(ftype)
5935 
      else:
5936 
        iprot.skip(ftype)
5937 
      iprot.readFieldEnd()
5938 
    iprot.readStructEnd()
5939 
 
5940 
  def write(self, oprot):
5941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5943 
      return
5944 
    oprot.writeStructBegin('getItemStatusDescription_args')
5945 
    if self.itemId is not None:
5946 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5947 
      oprot.writeI64(self.itemId)
5948 
      oprot.writeFieldEnd()
5949 
    oprot.writeFieldStop()
5950 
    oprot.writeStructEnd()
5951 
 
5952 
  def validate(self):
5953 
    return
5954 
 
5955 
 
5956 
  def __repr__(self):
5957 
    L = ['%s=%r' % (key, value)
5958 
      for key, value in self.__dict__.iteritems()]
5959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5960 
 
5961 
  def __eq__(self, other):
5962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5963 
 
5964 
  def __ne__(self, other):
5965 
    return not (self == other)
5966 
 
5967 
class getItemStatusDescription_result:
5968 
  """
5969 
  Attributes:
5970 
   - success
5971 
   - isex
5972 
  """
5973 
 
5974 
  thrift_spec = (
5975 
    (0, TType.STRING, 'success', None, None, ), # 0
5976 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5977 
  )
5978 
 
5979 
  def __init__(self, success=None, isex=None,):
5980 
    self.success = success
5981 
    self.isex = isex
5982 
 
5983 
  def read(self, iprot):
5984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5986 
      return
5987 
    iprot.readStructBegin()
5988 
    while True:
5989 
      (fname, ftype, fid) = iprot.readFieldBegin()
5990 
      if ftype == TType.STOP:
5991 
        break
5992 
      if fid == 0:
5993 
        if ftype == TType.STRING:
5994 
          self.success = iprot.readString();
5995 
        else:
5996 
          iprot.skip(ftype)
5997 
      elif fid == 1:
5998 
        if ftype == TType.STRUCT:
5999 
          self.isex = CatalogServiceException()
6000 
          self.isex.read(iprot)
6001 
        else:
6002 
          iprot.skip(ftype)
6003 
      else:
6004 
        iprot.skip(ftype)
6005 
      iprot.readFieldEnd()
6006 
    iprot.readStructEnd()
6007 
 
6008 
  def write(self, oprot):
6009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6011 
      return
6012 
    oprot.writeStructBegin('getItemStatusDescription_result')
6013 
    if self.success is not None:
6014 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6015 
      oprot.writeString(self.success)
6016 
      oprot.writeFieldEnd()
6017 
    if self.isex is not None:
6018 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6019 
      self.isex.write(oprot)
6020 
      oprot.writeFieldEnd()
6021 
    oprot.writeFieldStop()
6022 
    oprot.writeStructEnd()
6023 
 
6024 
  def validate(self):
6025 
    return
6026 
 
6027 
 
6028 
  def __repr__(self):
6029 
    L = ['%s=%r' % (key, value)
6030 
      for key, value in self.__dict__.iteritems()]
6031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6032 
 
6033 
  def __eq__(self, other):
6034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6035 
 
6036 
  def __ne__(self, other):
6037 
    return not (self == other)
6038 
 
6039 
class startItemOn_args:
6040 
  """
6041 
  Attributes:
6042 
   - item_id
6043 
   - timestamp
6044 
  """
6045 
 
6046 
  thrift_spec = (
6047 
    None, # 0
6048 
    (1, TType.I64, 'item_id', None, None, ), # 1
6049 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6050 
  )
6051 
 
6052 
  def __init__(self, item_id=None, timestamp=None,):
6053 
    self.item_id = item_id
6054 
    self.timestamp = timestamp
6055 
 
6056 
  def read(self, iprot):
6057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6059 
      return
6060 
    iprot.readStructBegin()
6061 
    while True:
6062 
      (fname, ftype, fid) = iprot.readFieldBegin()
6063 
      if ftype == TType.STOP:
6064 
        break
6065 
      if fid == 1:
6066 
        if ftype == TType.I64:
6067 
          self.item_id = iprot.readI64();
6068 
        else:
6069 
          iprot.skip(ftype)
6070 
      elif fid == 2:
6071 
        if ftype == TType.I64:
6072 
          self.timestamp = iprot.readI64();
6073 
        else:
6074 
          iprot.skip(ftype)
6075 
      else:
6076 
        iprot.skip(ftype)
6077 
      iprot.readFieldEnd()
6078 
    iprot.readStructEnd()
6079 
 
6080 
  def write(self, oprot):
6081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6083 
      return
6084 
    oprot.writeStructBegin('startItemOn_args')
6085 
    if self.item_id is not None:
6086 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6087 
      oprot.writeI64(self.item_id)
6088 
      oprot.writeFieldEnd()
6089 
    if self.timestamp is not None:
6090 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6091 
      oprot.writeI64(self.timestamp)
6092 
      oprot.writeFieldEnd()
6093 
    oprot.writeFieldStop()
6094 
    oprot.writeStructEnd()
6095 
 
6096 
  def validate(self):
6097 
    return
6098 
 
6099 
 
6100 
  def __repr__(self):
6101 
    L = ['%s=%r' % (key, value)
6102 
      for key, value in self.__dict__.iteritems()]
6103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6104 
 
6105 
  def __eq__(self, other):
6106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6107 
 
6108 
  def __ne__(self, other):
6109 
    return not (self == other)
6110 
 
6111 
class startItemOn_result:
6112 
  """
6113 
  Attributes:
6114 
   - cex
6115 
  """
6116 
 
6117 
  thrift_spec = (
6118 
    None, # 0
6119 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6120 
  )
6121 
 
6122 
  def __init__(self, cex=None,):
6123 
    self.cex = cex
6124 
 
6125 
  def read(self, iprot):
6126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6128 
      return
6129 
    iprot.readStructBegin()
6130 
    while True:
6131 
      (fname, ftype, fid) = iprot.readFieldBegin()
6132 
      if ftype == TType.STOP:
6133 
        break
6134 
      if fid == 1:
6135 
        if ftype == TType.STRUCT:
6136 
          self.cex = CatalogServiceException()
6137 
          self.cex.read(iprot)
6138 
        else:
6139 
          iprot.skip(ftype)
6140 
      else:
6141 
        iprot.skip(ftype)
6142 
      iprot.readFieldEnd()
6143 
    iprot.readStructEnd()
6144 
 
6145 
  def write(self, oprot):
6146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6148 
      return
6149 
    oprot.writeStructBegin('startItemOn_result')
6150 
    if self.cex is not None:
6151 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6152 
      self.cex.write(oprot)
6153 
      oprot.writeFieldEnd()
6154 
    oprot.writeFieldStop()
6155 
    oprot.writeStructEnd()
6156 
 
6157 
  def validate(self):
6158 
    return
6159 
 
6160 
 
6161 
  def __repr__(self):
6162 
    L = ['%s=%r' % (key, value)
6163 
      for key, value in self.__dict__.iteritems()]
6164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6165 
 
6166 
  def __eq__(self, other):
6167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6168 
 
6169 
  def __ne__(self, other):
6170 
    return not (self == other)
6171 
 
6172 
class retireItemOn_args:
6173 
  """
6174 
  Attributes:
6175 
   - item_id
6176 
   - timestamp
6177 
  """
6178 
 
6179 
  thrift_spec = (
6180 
    None, # 0
6181 
    (1, TType.I64, 'item_id', None, None, ), # 1
6182 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6183 
  )
6184 
 
6185 
  def __init__(self, item_id=None, timestamp=None,):
6186 
    self.item_id = item_id
6187 
    self.timestamp = timestamp
6188 
 
6189 
  def read(self, iprot):
6190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6192 
      return
6193 
    iprot.readStructBegin()
6194 
    while True:
6195 
      (fname, ftype, fid) = iprot.readFieldBegin()
6196 
      if ftype == TType.STOP:
6197 
        break
6198 
      if fid == 1:
6199 
        if ftype == TType.I64:
6200 
          self.item_id = iprot.readI64();
6201 
        else:
6202 
          iprot.skip(ftype)
6203 
      elif fid == 2:
6204 
        if ftype == TType.I64:
6205 
          self.timestamp = iprot.readI64();
6206 
        else:
6207 
          iprot.skip(ftype)
6208 
      else:
6209 
        iprot.skip(ftype)
6210 
      iprot.readFieldEnd()
6211 
    iprot.readStructEnd()
6212 
 
6213 
  def write(self, oprot):
6214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6216 
      return
6217 
    oprot.writeStructBegin('retireItemOn_args')
6218 
    if self.item_id is not None:
6219 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6220 
      oprot.writeI64(self.item_id)
6221 
      oprot.writeFieldEnd()
6222 
    if self.timestamp is not None:
6223 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6224 
      oprot.writeI64(self.timestamp)
6225 
      oprot.writeFieldEnd()
6226 
    oprot.writeFieldStop()
6227 
    oprot.writeStructEnd()
6228 
 
6229 
  def validate(self):
6230 
    return
6231 
 
6232 
 
6233 
  def __repr__(self):
6234 
    L = ['%s=%r' % (key, value)
6235 
      for key, value in self.__dict__.iteritems()]
6236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6237 
 
6238 
  def __eq__(self, other):
6239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6240 
 
6241 
  def __ne__(self, other):
6242 
    return not (self == other)
6243 
 
6244 
class retireItemOn_result:
6245 
  """
6246 
  Attributes:
6247 
   - cex
6248 
  """
6249 
 
6250 
  thrift_spec = (
6251 
    None, # 0
6252 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6253 
  )
6254 
 
6255 
  def __init__(self, cex=None,):
6256 
    self.cex = cex
6257 
 
6258 
  def read(self, iprot):
6259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6261 
      return
6262 
    iprot.readStructBegin()
6263 
    while True:
6264 
      (fname, ftype, fid) = iprot.readFieldBegin()
6265 
      if ftype == TType.STOP:
6266 
        break
6267 
      if fid == 1:
6268 
        if ftype == TType.STRUCT:
6269 
          self.cex = CatalogServiceException()
6270 
          self.cex.read(iprot)
6271 
        else:
6272 
          iprot.skip(ftype)
6273 
      else:
6274 
        iprot.skip(ftype)
6275 
      iprot.readFieldEnd()
6276 
    iprot.readStructEnd()
6277 
 
6278 
  def write(self, oprot):
6279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6281 
      return
6282 
    oprot.writeStructBegin('retireItemOn_result')
6283 
    if self.cex is not None:
6284 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6285 
      self.cex.write(oprot)
6286 
      oprot.writeFieldEnd()
6287 
    oprot.writeFieldStop()
6288 
    oprot.writeStructEnd()
6289 
 
6290 
  def validate(self):
6291 
    return
6292 
 
6293 
 
6294 
  def __repr__(self):
6295 
    L = ['%s=%r' % (key, value)
6296 
      for key, value in self.__dict__.iteritems()]
6297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6298 
 
6299 
  def __eq__(self, other):
6300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6301 
 
6302 
  def __ne__(self, other):
6303 
    return not (self == other)
6304 
 
6305 
class changeItemStatus_args:
6306 
  """
6307 
  Attributes:
6308 
   - item_id
6309 
   - timestamp
6310 
   - newstatus
6311 
  """
6312 
 
6313 
  thrift_spec = (
6314 
    None, # 0
6315 
    (1, TType.I64, 'item_id', None, None, ), # 1
6316 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6317 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6318 
  )
6319 
 
6320 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6321 
    self.item_id = item_id
6322 
    self.timestamp = timestamp
6323 
    self.newstatus = newstatus
6324 
 
6325 
  def read(self, iprot):
6326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6328 
      return
6329 
    iprot.readStructBegin()
6330 
    while True:
6331 
      (fname, ftype, fid) = iprot.readFieldBegin()
6332 
      if ftype == TType.STOP:
6333 
        break
6334 
      if fid == 1:
6335 
        if ftype == TType.I64:
6336 
          self.item_id = iprot.readI64();
6337 
        else:
6338 
          iprot.skip(ftype)
6339 
      elif fid == 2:
6340 
        if ftype == TType.I64:
6341 
          self.timestamp = iprot.readI64();
6342 
        else:
6343 
          iprot.skip(ftype)
6344 
      elif fid == 3:
6345 
        if ftype == TType.I32:
6346 
          self.newstatus = iprot.readI32();
6347 
        else:
6348 
          iprot.skip(ftype)
6349 
      else:
6350 
        iprot.skip(ftype)
6351 
      iprot.readFieldEnd()
6352 
    iprot.readStructEnd()
6353 
 
6354 
  def write(self, oprot):
6355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6357 
      return
6358 
    oprot.writeStructBegin('changeItemStatus_args')
6359 
    if self.item_id is not None:
6360 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6361 
      oprot.writeI64(self.item_id)
6362 
      oprot.writeFieldEnd()
6363 
    if self.timestamp is not None:
6364 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6365 
      oprot.writeI64(self.timestamp)
6366 
      oprot.writeFieldEnd()
6367 
    if self.newstatus is not None:
6368 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6369 
      oprot.writeI32(self.newstatus)
6370 
      oprot.writeFieldEnd()
6371 
    oprot.writeFieldStop()
6372 
    oprot.writeStructEnd()
6373 
 
6374 
  def validate(self):
6375 
    return
6376 
 
6377 
 
6378 
  def __repr__(self):
6379 
    L = ['%s=%r' % (key, value)
6380 
      for key, value in self.__dict__.iteritems()]
6381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6382 
 
6383 
  def __eq__(self, other):
6384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6385 
 
6386 
  def __ne__(self, other):
6387 
    return not (self == other)
6388 
 
6389 
class changeItemStatus_result:
6390 
  """
6391 
  Attributes:
6392 
   - cex
6393 
  """
6394 
 
6395 
  thrift_spec = (
6396 
    None, # 0
6397 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6398 
  )
6399 
 
6400 
  def __init__(self, cex=None,):
6401 
    self.cex = cex
6402 
 
6403 
  def read(self, iprot):
6404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6406 
      return
6407 
    iprot.readStructBegin()
6408 
    while True:
6409 
      (fname, ftype, fid) = iprot.readFieldBegin()
6410 
      if ftype == TType.STOP:
6411 
        break
6412 
      if fid == 1:
6413 
        if ftype == TType.STRUCT:
6414 
          self.cex = CatalogServiceException()
6415 
          self.cex.read(iprot)
6416 
        else:
6417 
          iprot.skip(ftype)
6418 
      else:
6419 
        iprot.skip(ftype)
6420 
      iprot.readFieldEnd()
6421 
    iprot.readStructEnd()
6422 
 
6423 
  def write(self, oprot):
6424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6426 
      return
6427 
    oprot.writeStructBegin('changeItemStatus_result')
6428 
    if self.cex is not None:
6429 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6430 
      self.cex.write(oprot)
6431 
      oprot.writeFieldEnd()
6432 
    oprot.writeFieldStop()
6433 
    oprot.writeStructEnd()
6434 
 
6435 
  def validate(self):
6436 
    return
6437 
 
6438 
 
6439 
  def __repr__(self):
6440 
    L = ['%s=%r' % (key, value)
6441 
      for key, value in self.__dict__.iteritems()]
6442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6443 
 
6444 
  def __eq__(self, other):
6445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6446 
 
6447 
  def __ne__(self, other):
6448 
    return not (self == other)
6449 
 
6450 
class getItem_args:
6451 
  """
6452 
  Attributes:
6453 
   - item_id
6454 
  """
6455 
 
6456 
  thrift_spec = (
6457 
    None, # 0
6458 
    (1, TType.I64, 'item_id', None, None, ), # 1
6459 
  )
6460 
 
6461 
  def __init__(self, item_id=None,):
6462 
    self.item_id = item_id
6463 
 
6464 
  def read(self, iprot):
6465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6467 
      return
6468 
    iprot.readStructBegin()
6469 
    while True:
6470 
      (fname, ftype, fid) = iprot.readFieldBegin()
6471 
      if ftype == TType.STOP:
6472 
        break
6473 
      if fid == 1:
6474 
        if ftype == TType.I64:
6475 
          self.item_id = iprot.readI64();
6476 
        else:
6477 
          iprot.skip(ftype)
6478 
      else:
6479 
        iprot.skip(ftype)
6480 
      iprot.readFieldEnd()
6481 
    iprot.readStructEnd()
6482 
 
6483 
  def write(self, oprot):
6484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6486 
      return
6487 
    oprot.writeStructBegin('getItem_args')
6488 
    if self.item_id is not None:
6489 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6490 
      oprot.writeI64(self.item_id)
6491 
      oprot.writeFieldEnd()
6492 
    oprot.writeFieldStop()
6493 
    oprot.writeStructEnd()
6494 
 
6495 
  def validate(self):
6496 
    return
6497 
 
6498 
 
6499 
  def __repr__(self):
6500 
    L = ['%s=%r' % (key, value)
6501 
      for key, value in self.__dict__.iteritems()]
6502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6503 
 
6504 
  def __eq__(self, other):
6505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6506 
 
6507 
  def __ne__(self, other):
6508 
    return not (self == other)
6509 
 
6510 
class getItem_result:
6511 
  """
6512 
  Attributes:
6513 
   - success
6514 
   - cex
6515 
  """
6516 
 
6517 
  thrift_spec = (
6518 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6519 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6520 
  )
6521 
 
6522 
  def __init__(self, success=None, cex=None,):
6523 
    self.success = success
6524 
    self.cex = cex
6525 
 
6526 
  def read(self, iprot):
6527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6529 
      return
6530 
    iprot.readStructBegin()
6531 
    while True:
6532 
      (fname, ftype, fid) = iprot.readFieldBegin()
6533 
      if ftype == TType.STOP:
6534 
        break
6535 
      if fid == 0:
6536 
        if ftype == TType.STRUCT:
6537 
          self.success = Item()
6538 
          self.success.read(iprot)
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      elif fid == 1:
6542 
        if ftype == TType.STRUCT:
6543 
          self.cex = CatalogServiceException()
6544 
          self.cex.read(iprot)
6545 
        else:
6546 
          iprot.skip(ftype)
6547 
      else:
6548 
        iprot.skip(ftype)
6549 
      iprot.readFieldEnd()
6550 
    iprot.readStructEnd()
6551 
 
6552 
  def write(self, oprot):
6553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6555 
      return
6556 
    oprot.writeStructBegin('getItem_result')
6557 
    if self.success is not None:
6558 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6559 
      self.success.write(oprot)
6560 
      oprot.writeFieldEnd()
6561 
    if self.cex is not None:
6562 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6563 
      self.cex.write(oprot)
6564 
      oprot.writeFieldEnd()
6565 
    oprot.writeFieldStop()
6566 
    oprot.writeStructEnd()
6567 
 
6568 
  def validate(self):
6569 
    return
6570 
 
6571 
 
6572 
  def __repr__(self):
6573 
    L = ['%s=%r' % (key, value)
6574 
      for key, value in self.__dict__.iteritems()]
6575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6576 
 
6577 
  def __eq__(self, other):
6578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6579 
 
6580 
  def __ne__(self, other):
6581 
    return not (self == other)
6582 
 
6583 
class getItemsByCatalogId_args:
6584 
  """
6585 
  Attributes:
6586 
   - catalog_item_id
6587 
  """
6588 
 
6589 
  thrift_spec = (
6590 
    None, # 0
6591 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6592 
  )
6593 
 
6594 
  def __init__(self, catalog_item_id=None,):
6595 
    self.catalog_item_id = catalog_item_id
6596 
 
6597 
  def read(self, iprot):
6598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6600 
      return
6601 
    iprot.readStructBegin()
6602 
    while True:
6603 
      (fname, ftype, fid) = iprot.readFieldBegin()
6604 
      if ftype == TType.STOP:
6605 
        break
6606 
      if fid == 1:
6607 
        if ftype == TType.I64:
6608 
          self.catalog_item_id = iprot.readI64();
6609 
        else:
6610 
          iprot.skip(ftype)
6611 
      else:
6612 
        iprot.skip(ftype)
6613 
      iprot.readFieldEnd()
6614 
    iprot.readStructEnd()
6615 
 
6616 
  def write(self, oprot):
6617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6619 
      return
6620 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6621 
    if self.catalog_item_id is not None:
6622 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6623 
      oprot.writeI64(self.catalog_item_id)
6624 
      oprot.writeFieldEnd()
6625 
    oprot.writeFieldStop()
6626 
    oprot.writeStructEnd()
6627 
 
6628 
  def validate(self):
6629 
    return
6630 
 
6631 
 
6632 
  def __repr__(self):
6633 
    L = ['%s=%r' % (key, value)
6634 
      for key, value in self.__dict__.iteritems()]
6635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6636 
 
6637 
  def __eq__(self, other):
6638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6639 
 
6640 
  def __ne__(self, other):
6641 
    return not (self == other)
6642 
 
6643 
class getItemsByCatalogId_result:
6644 
  """
6645 
  Attributes:
6646 
   - success
6647 
   - cex
6648 
  """
6649 
 
6650 
  thrift_spec = (
6651 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6652 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6653 
  )
6654 
 
6655 
  def __init__(self, success=None, cex=None,):
6656 
    self.success = success
6657 
    self.cex = cex
6658 
 
6659 
  def read(self, iprot):
6660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6662 
      return
6663 
    iprot.readStructBegin()
6664 
    while True:
6665 
      (fname, ftype, fid) = iprot.readFieldBegin()
6666 
      if ftype == TType.STOP:
6667 
        break
6668 
      if fid == 0:
6669 
        if ftype == TType.LIST:
6670 
          self.success = []
7438 amit.gupta 6671 
          (_etype35, _size32) = iprot.readListBegin()
6672 
          for _i36 in xrange(_size32):
6673 
            _elem37 = Item()
6674 
            _elem37.read(iprot)
6675 
            self.success.append(_elem37)
5944 mandeep.dh 6676 
          iprot.readListEnd()
6677 
        else:
6678 
          iprot.skip(ftype)
6679 
      elif fid == 1:
6680 
        if ftype == TType.STRUCT:
6681 
          self.cex = CatalogServiceException()
6682 
          self.cex.read(iprot)
6683 
        else:
6684 
          iprot.skip(ftype)
6685 
      else:
6686 
        iprot.skip(ftype)
6687 
      iprot.readFieldEnd()
6688 
    iprot.readStructEnd()
6689 
 
6690 
  def write(self, oprot):
6691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6693 
      return
6694 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6695 
    if self.success is not None:
6696 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6697 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6698 
      for iter38 in self.success:
6699 
        iter38.write(oprot)
5944 mandeep.dh 6700 
      oprot.writeListEnd()
6701 
      oprot.writeFieldEnd()
6702 
    if self.cex is not None:
6703 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6704 
      self.cex.write(oprot)
6705 
      oprot.writeFieldEnd()
6706 
    oprot.writeFieldStop()
6707 
    oprot.writeStructEnd()
6708 
 
6709 
  def validate(self):
6710 
    return
6711 
 
6712 
 
6713 
  def __repr__(self):
6714 
    L = ['%s=%r' % (key, value)
6715 
      for key, value in self.__dict__.iteritems()]
6716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6717 
 
6718 
  def __eq__(self, other):
6719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6720 
 
6721 
  def __ne__(self, other):
6722 
    return not (self == other)
6723 
 
6724 
class getValidItemsByCatalogId_args:
6725 
  """
6726 
  Attributes:
6727 
   - catalog_item_id
6728 
  """
6729 
 
6730 
  thrift_spec = (
6731 
    None, # 0
6732 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6733 
  )
6734 
 
6735 
  def __init__(self, catalog_item_id=None,):
6736 
    self.catalog_item_id = catalog_item_id
6737 
 
6738 
  def read(self, iprot):
6739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6741 
      return
6742 
    iprot.readStructBegin()
6743 
    while True:
6744 
      (fname, ftype, fid) = iprot.readFieldBegin()
6745 
      if ftype == TType.STOP:
6746 
        break
6747 
      if fid == 1:
6748 
        if ftype == TType.I64:
6749 
          self.catalog_item_id = iprot.readI64();
6750 
        else:
6751 
          iprot.skip(ftype)
6752 
      else:
6753 
        iprot.skip(ftype)
6754 
      iprot.readFieldEnd()
6755 
    iprot.readStructEnd()
6756 
 
6757 
  def write(self, oprot):
6758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6760 
      return
6761 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6762 
    if self.catalog_item_id is not None:
6763 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6764 
      oprot.writeI64(self.catalog_item_id)
6765 
      oprot.writeFieldEnd()
6766 
    oprot.writeFieldStop()
6767 
    oprot.writeStructEnd()
6768 
 
6769 
  def validate(self):
6770 
    return
6771 
 
6772 
 
6773 
  def __repr__(self):
6774 
    L = ['%s=%r' % (key, value)
6775 
      for key, value in self.__dict__.iteritems()]
6776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6777 
 
6778 
  def __eq__(self, other):
6779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6780 
 
6781 
  def __ne__(self, other):
6782 
    return not (self == other)
6783 
 
6784 
class getValidItemsByCatalogId_result:
6785 
  """
6786 
  Attributes:
6787 
   - success
6788 
   - cex
6789 
  """
6790 
 
6791 
  thrift_spec = (
6792 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6793 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6794 
  )
6795 
 
6796 
  def __init__(self, success=None, cex=None,):
6797 
    self.success = success
6798 
    self.cex = cex
6799 
 
6800 
  def read(self, iprot):
6801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6803 
      return
6804 
    iprot.readStructBegin()
6805 
    while True:
6806 
      (fname, ftype, fid) = iprot.readFieldBegin()
6807 
      if ftype == TType.STOP:
6808 
        break
6809 
      if fid == 0:
6810 
        if ftype == TType.LIST:
6811 
          self.success = []
7438 amit.gupta 6812 
          (_etype42, _size39) = iprot.readListBegin()
6813 
          for _i43 in xrange(_size39):
6814 
            _elem44 = Item()
6815 
            _elem44.read(iprot)
6816 
            self.success.append(_elem44)
5944 mandeep.dh 6817 
          iprot.readListEnd()
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('getValidItemsByCatalogId_result')
6836 
    if self.success is not None:
6837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6839 
      for iter45 in self.success:
6840 
        iter45.write(oprot)
5944 mandeep.dh 6841 
      oprot.writeListEnd()
6842 
      oprot.writeFieldEnd()
6843 
    if self.cex is not None:
6844 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6845 
      self.cex.write(oprot)
6846 
      oprot.writeFieldEnd()
6847 
    oprot.writeFieldStop()
6848 
    oprot.writeStructEnd()
6849 
 
6850 
  def validate(self):
6851 
    return
6852 
 
6853 
 
6854 
  def __repr__(self):
6855 
    L = ['%s=%r' % (key, value)
6856 
      for key, value in self.__dict__.iteritems()]
6857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6858 
 
6859 
  def __eq__(self, other):
6860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6861 
 
6862 
  def __ne__(self, other):
6863 
    return not (self == other)
6864 
 
6865 
class getAllItems_args:
6866 
  """
6867 
  Attributes:
6868 
   - isActive
6869 
  """
6870 
 
6871 
  thrift_spec = (
6872 
    None, # 0
6873 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6874 
  )
6875 
 
6876 
  def __init__(self, isActive=None,):
6877 
    self.isActive = isActive
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.BOOL:
6890 
          self.isActive = iprot.readBool();
6891 
        else:
6892 
          iprot.skip(ftype)
6893 
      else:
6894 
        iprot.skip(ftype)
6895 
      iprot.readFieldEnd()
6896 
    iprot.readStructEnd()
6897 
 
6898 
  def write(self, oprot):
6899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6901 
      return
6902 
    oprot.writeStructBegin('getAllItems_args')
6903 
    if self.isActive is not None:
6904 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6905 
      oprot.writeBool(self.isActive)
6906 
      oprot.writeFieldEnd()
6907 
    oprot.writeFieldStop()
6908 
    oprot.writeStructEnd()
6909 
 
6910 
  def validate(self):
6911 
    return
6912 
 
6913 
 
6914 
  def __repr__(self):
6915 
    L = ['%s=%r' % (key, value)
6916 
      for key, value in self.__dict__.iteritems()]
6917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6918 
 
6919 
  def __eq__(self, other):
6920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6921 
 
6922 
  def __ne__(self, other):
6923 
    return not (self == other)
6924 
 
6925 
class getAllItems_result:
6926 
  """
6927 
  Attributes:
6928 
   - success
6929 
   - cex
6930 
  """
6931 
 
6932 
  thrift_spec = (
6933 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6934 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6935 
  )
6936 
 
6937 
  def __init__(self, success=None, cex=None,):
6938 
    self.success = success
6939 
    self.cex = cex
6940 
 
6941 
  def read(self, iprot):
6942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6944 
      return
6945 
    iprot.readStructBegin()
6946 
    while True:
6947 
      (fname, ftype, fid) = iprot.readFieldBegin()
6948 
      if ftype == TType.STOP:
6949 
        break
6950 
      if fid == 0:
6951 
        if ftype == TType.LIST:
6952 
          self.success = []
7438 amit.gupta 6953 
          (_etype49, _size46) = iprot.readListBegin()
6954 
          for _i50 in xrange(_size46):
6955 
            _elem51 = Item()
6956 
            _elem51.read(iprot)
6957 
            self.success.append(_elem51)
5944 mandeep.dh 6958 
          iprot.readListEnd()
6959 
        else:
6960 
          iprot.skip(ftype)
6961 
      elif fid == 1:
6962 
        if ftype == TType.STRUCT:
6963 
          self.cex = CatalogServiceException()
6964 
          self.cex.read(iprot)
6965 
        else:
6966 
          iprot.skip(ftype)
6967 
      else:
6968 
        iprot.skip(ftype)
6969 
      iprot.readFieldEnd()
6970 
    iprot.readStructEnd()
6971 
 
6972 
  def write(self, oprot):
6973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6975 
      return
6976 
    oprot.writeStructBegin('getAllItems_result')
6977 
    if self.success is not None:
6978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6980 
      for iter52 in self.success:
6981 
        iter52.write(oprot)
5944 mandeep.dh 6982 
      oprot.writeListEnd()
6983 
      oprot.writeFieldEnd()
6984 
    if self.cex is not None:
6985 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6986 
      self.cex.write(oprot)
6987 
      oprot.writeFieldEnd()
6988 
    oprot.writeFieldStop()
6989 
    oprot.writeStructEnd()
6990 
 
6991 
  def validate(self):
6992 
    return
6993 
 
6994 
 
6995 
  def __repr__(self):
6996 
    L = ['%s=%r' % (key, value)
6997 
      for key, value in self.__dict__.iteritems()]
6998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6999 
 
7000 
  def __eq__(self, other):
7001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7002 
 
7003 
  def __ne__(self, other):
7004 
    return not (self == other)
7005 
 
7006 
class getAllItemsByStatus_args:
7007 
  """
7008 
  Attributes:
7009 
   - itemStatus
7010 
  """
7011 
 
7012 
  thrift_spec = (
7013 
    None, # 0
7014 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7015 
  )
7016 
 
7017 
  def __init__(self, itemStatus=None,):
7018 
    self.itemStatus = itemStatus
7019 
 
7020 
  def read(self, iprot):
7021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7023 
      return
7024 
    iprot.readStructBegin()
7025 
    while True:
7026 
      (fname, ftype, fid) = iprot.readFieldBegin()
7027 
      if ftype == TType.STOP:
7028 
        break
7029 
      if fid == 1:
7030 
        if ftype == TType.I32:
7031 
          self.itemStatus = iprot.readI32();
7032 
        else:
7033 
          iprot.skip(ftype)
7034 
      else:
7035 
        iprot.skip(ftype)
7036 
      iprot.readFieldEnd()
7037 
    iprot.readStructEnd()
7038 
 
7039 
  def write(self, oprot):
7040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7042 
      return
7043 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7044 
    if self.itemStatus is not None:
7045 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7046 
      oprot.writeI32(self.itemStatus)
7047 
      oprot.writeFieldEnd()
7048 
    oprot.writeFieldStop()
7049 
    oprot.writeStructEnd()
7050 
 
7051 
  def validate(self):
7052 
    return
7053 
 
7054 
 
7055 
  def __repr__(self):
7056 
    L = ['%s=%r' % (key, value)
7057 
      for key, value in self.__dict__.iteritems()]
7058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7059 
 
7060 
  def __eq__(self, other):
7061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7062 
 
7063 
  def __ne__(self, other):
7064 
    return not (self == other)
7065 
 
7066 
class getAllItemsByStatus_result:
7067 
  """
7068 
  Attributes:
7069 
   - success
7070 
   - cex
7071 
  """
7072 
 
7073 
  thrift_spec = (
7074 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7075 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7076 
  )
7077 
 
7078 
  def __init__(self, success=None, cex=None,):
7079 
    self.success = success
7080 
    self.cex = cex
7081 
 
7082 
  def read(self, iprot):
7083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7085 
      return
7086 
    iprot.readStructBegin()
7087 
    while True:
7088 
      (fname, ftype, fid) = iprot.readFieldBegin()
7089 
      if ftype == TType.STOP:
7090 
        break
7091 
      if fid == 0:
7092 
        if ftype == TType.LIST:
7093 
          self.success = []
7438 amit.gupta 7094 
          (_etype56, _size53) = iprot.readListBegin()
7095 
          for _i57 in xrange(_size53):
7096 
            _elem58 = Item()
7097 
            _elem58.read(iprot)
7098 
            self.success.append(_elem58)
5944 mandeep.dh 7099 
          iprot.readListEnd()
7100 
        else:
7101 
          iprot.skip(ftype)
7102 
      elif fid == 1:
7103 
        if ftype == TType.STRUCT:
7104 
          self.cex = CatalogServiceException()
7105 
          self.cex.read(iprot)
7106 
        else:
7107 
          iprot.skip(ftype)
7108 
      else:
7109 
        iprot.skip(ftype)
7110 
      iprot.readFieldEnd()
7111 
    iprot.readStructEnd()
7112 
 
7113 
  def write(self, oprot):
7114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7116 
      return
7117 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7118 
    if self.success is not None:
7119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7120 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7121 
      for iter59 in self.success:
7122 
        iter59.write(oprot)
5944 mandeep.dh 7123 
      oprot.writeListEnd()
7124 
      oprot.writeFieldEnd()
7125 
    if self.cex is not None:
7126 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7127 
      self.cex.write(oprot)
7128 
      oprot.writeFieldEnd()
7129 
    oprot.writeFieldStop()
7130 
    oprot.writeStructEnd()
7131 
 
7132 
  def validate(self):
7133 
    return
7134 
 
7135 
 
7136 
  def __repr__(self):
7137 
    L = ['%s=%r' % (key, value)
7138 
      for key, value in self.__dict__.iteritems()]
7139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7140 
 
7141 
  def __eq__(self, other):
7142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7143 
 
7144 
  def __ne__(self, other):
7145 
    return not (self == other)
7146 
 
7147 
class markItemAsContentComplete_args:
7148 
  """
7149 
  Attributes:
7150 
   - entityId
7151 
   - category
7152 
   - brand
7153 
   - modelName
7154 
   - modelNumber
7155 
  """
7156 
 
7157 
  thrift_spec = (
7158 
    None, # 0
7159 
    (1, TType.I64, 'entityId', None, None, ), # 1
7160 
    (2, TType.I64, 'category', None, None, ), # 2
7161 
    (3, TType.STRING, 'brand', None, None, ), # 3
7162 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7163 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7164 
  )
7165 
 
7166 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7167 
    self.entityId = entityId
7168 
    self.category = category
7169 
    self.brand = brand
7170 
    self.modelName = modelName
7171 
    self.modelNumber = modelNumber
7172 
 
7173 
  def read(self, iprot):
7174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7176 
      return
7177 
    iprot.readStructBegin()
7178 
    while True:
7179 
      (fname, ftype, fid) = iprot.readFieldBegin()
7180 
      if ftype == TType.STOP:
7181 
        break
7182 
      if fid == 1:
7183 
        if ftype == TType.I64:
7184 
          self.entityId = iprot.readI64();
7185 
        else:
7186 
          iprot.skip(ftype)
7187 
      elif fid == 2:
7188 
        if ftype == TType.I64:
7189 
          self.category = iprot.readI64();
7190 
        else:
7191 
          iprot.skip(ftype)
7192 
      elif fid == 3:
7193 
        if ftype == TType.STRING:
7194 
          self.brand = iprot.readString();
7195 
        else:
7196 
          iprot.skip(ftype)
7197 
      elif fid == 4:
7198 
        if ftype == TType.STRING:
7199 
          self.modelName = iprot.readString();
7200 
        else:
7201 
          iprot.skip(ftype)
7202 
      elif fid == 5:
7203 
        if ftype == TType.STRING:
7204 
          self.modelNumber = iprot.readString();
7205 
        else:
7206 
          iprot.skip(ftype)
7207 
      else:
7208 
        iprot.skip(ftype)
7209 
      iprot.readFieldEnd()
7210 
    iprot.readStructEnd()
7211 
 
7212 
  def write(self, oprot):
7213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7215 
      return
7216 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7217 
    if self.entityId is not None:
7218 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7219 
      oprot.writeI64(self.entityId)
7220 
      oprot.writeFieldEnd()
7221 
    if self.category is not None:
7222 
      oprot.writeFieldBegin('category', TType.I64, 2)
7223 
      oprot.writeI64(self.category)
7224 
      oprot.writeFieldEnd()
7225 
    if self.brand is not None:
7226 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7227 
      oprot.writeString(self.brand)
7228 
      oprot.writeFieldEnd()
7229 
    if self.modelName is not None:
7230 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7231 
      oprot.writeString(self.modelName)
7232 
      oprot.writeFieldEnd()
7233 
    if self.modelNumber is not None:
7234 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7235 
      oprot.writeString(self.modelNumber)
7236 
      oprot.writeFieldEnd()
7237 
    oprot.writeFieldStop()
7238 
    oprot.writeStructEnd()
7239 
 
7240 
  def validate(self):
7241 
    return
7242 
 
7243 
 
7244 
  def __repr__(self):
7245 
    L = ['%s=%r' % (key, value)
7246 
      for key, value in self.__dict__.iteritems()]
7247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7248 
 
7249 
  def __eq__(self, other):
7250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7251 
 
7252 
  def __ne__(self, other):
7253 
    return not (self == other)
7254 
 
7255 
class markItemAsContentComplete_result:
7256 
  """
7257 
  Attributes:
7258 
   - success
7259 
   - cex
7260 
  """
7261 
 
7262 
  thrift_spec = (
7263 
    (0, TType.BOOL, 'success', None, None, ), # 0
7264 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7265 
  )
7266 
 
7267 
  def __init__(self, success=None, cex=None,):
7268 
    self.success = success
7269 
    self.cex = cex
7270 
 
7271 
  def read(self, iprot):
7272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7274 
      return
7275 
    iprot.readStructBegin()
7276 
    while True:
7277 
      (fname, ftype, fid) = iprot.readFieldBegin()
7278 
      if ftype == TType.STOP:
7279 
        break
7280 
      if fid == 0:
7281 
        if ftype == TType.BOOL:
7282 
          self.success = iprot.readBool();
7283 
        else:
7284 
          iprot.skip(ftype)
7285 
      elif fid == 1:
7286 
        if ftype == TType.STRUCT:
7287 
          self.cex = CatalogServiceException()
7288 
          self.cex.read(iprot)
7289 
        else:
7290 
          iprot.skip(ftype)
7291 
      else:
7292 
        iprot.skip(ftype)
7293 
      iprot.readFieldEnd()
7294 
    iprot.readStructEnd()
7295 
 
7296 
  def write(self, oprot):
7297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7299 
      return
7300 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7301 
    if self.success is not None:
7302 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7303 
      oprot.writeBool(self.success)
7304 
      oprot.writeFieldEnd()
7305 
    if self.cex is not None:
7306 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7307 
      self.cex.write(oprot)
7308 
      oprot.writeFieldEnd()
7309 
    oprot.writeFieldStop()
7310 
    oprot.writeStructEnd()
7311 
 
7312 
  def validate(self):
7313 
    return
7314 
 
7315 
 
7316 
  def __repr__(self):
7317 
    L = ['%s=%r' % (key, value)
7318 
      for key, value in self.__dict__.iteritems()]
7319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7320 
 
7321 
  def __eq__(self, other):
7322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7323 
 
7324 
  def __ne__(self, other):
7325 
    return not (self == other)
7326 
 
7327 
class getAllItemsInRange_args:
7328 
  """
7329 
  Attributes:
7330 
   - offset
7331 
   - limit
7332 
  """
7333 
 
7334 
  thrift_spec = (
7335 
    None, # 0
7336 
    (1, TType.I64, 'offset', None, None, ), # 1
7337 
    (2, TType.I64, 'limit', None, None, ), # 2
7338 
  )
7339 
 
7340 
  def __init__(self, offset=None, limit=None,):
7341 
    self.offset = offset
7342 
    self.limit = limit
7343 
 
7344 
  def read(self, iprot):
7345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7347 
      return
7348 
    iprot.readStructBegin()
7349 
    while True:
7350 
      (fname, ftype, fid) = iprot.readFieldBegin()
7351 
      if ftype == TType.STOP:
7352 
        break
7353 
      if fid == 1:
7354 
        if ftype == TType.I64:
7355 
          self.offset = iprot.readI64();
7356 
        else:
7357 
          iprot.skip(ftype)
7358 
      elif fid == 2:
7359 
        if ftype == TType.I64:
7360 
          self.limit = iprot.readI64();
7361 
        else:
7362 
          iprot.skip(ftype)
7363 
      else:
7364 
        iprot.skip(ftype)
7365 
      iprot.readFieldEnd()
7366 
    iprot.readStructEnd()
7367 
 
7368 
  def write(self, oprot):
7369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7371 
      return
7372 
    oprot.writeStructBegin('getAllItemsInRange_args')
7373 
    if self.offset is not None:
7374 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7375 
      oprot.writeI64(self.offset)
7376 
      oprot.writeFieldEnd()
7377 
    if self.limit is not None:
7378 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7379 
      oprot.writeI64(self.limit)
7380 
      oprot.writeFieldEnd()
7381 
    oprot.writeFieldStop()
7382 
    oprot.writeStructEnd()
7383 
 
7384 
  def validate(self):
7385 
    return
7386 
 
7387 
 
7388 
  def __repr__(self):
7389 
    L = ['%s=%r' % (key, value)
7390 
      for key, value in self.__dict__.iteritems()]
7391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7392 
 
7393 
  def __eq__(self, other):
7394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7395 
 
7396 
  def __ne__(self, other):
7397 
    return not (self == other)
7398 
 
7399 
class getAllItemsInRange_result:
7400 
  """
7401 
  Attributes:
7402 
   - success
7403 
   - cex
7404 
  """
7405 
 
7406 
  thrift_spec = (
7407 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7408 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7409 
  )
7410 
 
7411 
  def __init__(self, success=None, cex=None,):
7412 
    self.success = success
7413 
    self.cex = cex
7414 
 
7415 
  def read(self, iprot):
7416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7418 
      return
7419 
    iprot.readStructBegin()
7420 
    while True:
7421 
      (fname, ftype, fid) = iprot.readFieldBegin()
7422 
      if ftype == TType.STOP:
7423 
        break
7424 
      if fid == 0:
7425 
        if ftype == TType.LIST:
7426 
          self.success = []
7438 amit.gupta 7427 
          (_etype63, _size60) = iprot.readListBegin()
7428 
          for _i64 in xrange(_size60):
7429 
            _elem65 = Item()
7430 
            _elem65.read(iprot)
7431 
            self.success.append(_elem65)
5944 mandeep.dh 7432 
          iprot.readListEnd()
7433 
        else:
7434 
          iprot.skip(ftype)
7435 
      elif fid == 1:
7436 
        if ftype == TType.STRUCT:
7437 
          self.cex = CatalogServiceException()
7438 
          self.cex.read(iprot)
7439 
        else:
7440 
          iprot.skip(ftype)
7441 
      else:
7442 
        iprot.skip(ftype)
7443 
      iprot.readFieldEnd()
7444 
    iprot.readStructEnd()
7445 
 
7446 
  def write(self, oprot):
7447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7449 
      return
7450 
    oprot.writeStructBegin('getAllItemsInRange_result')
7451 
    if self.success is not None:
7452 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7453 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7454 
      for iter66 in self.success:
7455 
        iter66.write(oprot)
5944 mandeep.dh 7456 
      oprot.writeListEnd()
7457 
      oprot.writeFieldEnd()
7458 
    if self.cex is not None:
7459 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7460 
      self.cex.write(oprot)
7461 
      oprot.writeFieldEnd()
7462 
    oprot.writeFieldStop()
7463 
    oprot.writeStructEnd()
7464 
 
7465 
  def validate(self):
7466 
    return
7467 
 
7468 
 
7469 
  def __repr__(self):
7470 
    L = ['%s=%r' % (key, value)
7471 
      for key, value in self.__dict__.iteritems()]
7472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7473 
 
7474 
  def __eq__(self, other):
7475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7476 
 
7477 
  def __ne__(self, other):
7478 
    return not (self == other)
7479 
 
7480 
class getAllItemsByStatusInRange_args:
7481 
  """
7482 
  Attributes:
7483 
   - itemStatus
7484 
   - offset
7485 
   - limit
7486 
  """
7487 
 
7488 
  thrift_spec = (
7489 
    None, # 0
7490 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7491 
    (2, TType.I64, 'offset', None, None, ), # 2
7492 
    (3, TType.I64, 'limit', None, None, ), # 3
7493 
  )
7494 
 
7495 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7496 
    self.itemStatus = itemStatus
7497 
    self.offset = offset
7498 
    self.limit = limit
7499 
 
7500 
  def read(self, iprot):
7501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7503 
      return
7504 
    iprot.readStructBegin()
7505 
    while True:
7506 
      (fname, ftype, fid) = iprot.readFieldBegin()
7507 
      if ftype == TType.STOP:
7508 
        break
7509 
      if fid == 1:
7510 
        if ftype == TType.I32:
7511 
          self.itemStatus = iprot.readI32();
7512 
        else:
7513 
          iprot.skip(ftype)
7514 
      elif fid == 2:
7515 
        if ftype == TType.I64:
7516 
          self.offset = iprot.readI64();
7517 
        else:
7518 
          iprot.skip(ftype)
7519 
      elif fid == 3:
7520 
        if ftype == TType.I64:
7521 
          self.limit = iprot.readI64();
7522 
        else:
7523 
          iprot.skip(ftype)
7524 
      else:
7525 
        iprot.skip(ftype)
7526 
      iprot.readFieldEnd()
7527 
    iprot.readStructEnd()
7528 
 
7529 
  def write(self, oprot):
7530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7532 
      return
7533 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7534 
    if self.itemStatus is not None:
7535 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7536 
      oprot.writeI32(self.itemStatus)
7537 
      oprot.writeFieldEnd()
7538 
    if self.offset is not None:
7539 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7540 
      oprot.writeI64(self.offset)
7541 
      oprot.writeFieldEnd()
7542 
    if self.limit is not None:
7543 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7544 
      oprot.writeI64(self.limit)
7545 
      oprot.writeFieldEnd()
7546 
    oprot.writeFieldStop()
7547 
    oprot.writeStructEnd()
7548 
 
7549 
  def validate(self):
7550 
    return
7551 
 
7552 
 
7553 
  def __repr__(self):
7554 
    L = ['%s=%r' % (key, value)
7555 
      for key, value in self.__dict__.iteritems()]
7556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7557 
 
7558 
  def __eq__(self, other):
7559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7560 
 
7561 
  def __ne__(self, other):
7562 
    return not (self == other)
7563 
 
7564 
class getAllItemsByStatusInRange_result:
7565 
  """
7566 
  Attributes:
7567 
   - success
7568 
   - cex
7569 
  """
7570 
 
7571 
  thrift_spec = (
7572 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7573 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7574 
  )
7575 
 
7576 
  def __init__(self, success=None, cex=None,):
7577 
    self.success = success
7578 
    self.cex = cex
7579 
 
7580 
  def read(self, iprot):
7581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7583 
      return
7584 
    iprot.readStructBegin()
7585 
    while True:
7586 
      (fname, ftype, fid) = iprot.readFieldBegin()
7587 
      if ftype == TType.STOP:
7588 
        break
7589 
      if fid == 0:
7590 
        if ftype == TType.LIST:
7591 
          self.success = []
7438 amit.gupta 7592 
          (_etype70, _size67) = iprot.readListBegin()
7593 
          for _i71 in xrange(_size67):
7594 
            _elem72 = Item()
7595 
            _elem72.read(iprot)
7596 
            self.success.append(_elem72)
5944 mandeep.dh 7597 
          iprot.readListEnd()
7598 
        else:
7599 
          iprot.skip(ftype)
7600 
      elif fid == 1:
7601 
        if ftype == TType.STRUCT:
7602 
          self.cex = CatalogServiceException()
7603 
          self.cex.read(iprot)
7604 
        else:
7605 
          iprot.skip(ftype)
7606 
      else:
7607 
        iprot.skip(ftype)
7608 
      iprot.readFieldEnd()
7609 
    iprot.readStructEnd()
7610 
 
7611 
  def write(self, oprot):
7612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7614 
      return
7615 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7616 
    if self.success is not None:
7617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7618 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7619 
      for iter73 in self.success:
7620 
        iter73.write(oprot)
5944 mandeep.dh 7621 
      oprot.writeListEnd()
7622 
      oprot.writeFieldEnd()
7623 
    if self.cex is not None:
7624 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7625 
      self.cex.write(oprot)
7626 
      oprot.writeFieldEnd()
7627 
    oprot.writeFieldStop()
7628 
    oprot.writeStructEnd()
7629 
 
7630 
  def validate(self):
7631 
    return
7632 
 
7633 
 
7634 
  def __repr__(self):
7635 
    L = ['%s=%r' % (key, value)
7636 
      for key, value in self.__dict__.iteritems()]
7637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7638 
 
7639 
  def __eq__(self, other):
7640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7641 
 
7642 
  def __ne__(self, other):
7643 
    return not (self == other)
7644 
 
7645 
class getItemCountByStatus_args:
7646 
  """
7647 
  Attributes:
7648 
   - useStatus
7649 
   - itemStatus
7650 
  """
7651 
 
7652 
  thrift_spec = (
7653 
    None, # 0
7654 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7655 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7656 
  )
7657 
 
7658 
  def __init__(self, useStatus=None, itemStatus=None,):
7659 
    self.useStatus = useStatus
7660 
    self.itemStatus = itemStatus
7661 
 
7662 
  def read(self, iprot):
7663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7665 
      return
7666 
    iprot.readStructBegin()
7667 
    while True:
7668 
      (fname, ftype, fid) = iprot.readFieldBegin()
7669 
      if ftype == TType.STOP:
7670 
        break
7671 
      if fid == 1:
7672 
        if ftype == TType.BOOL:
7673 
          self.useStatus = iprot.readBool();
7674 
        else:
7675 
          iprot.skip(ftype)
7676 
      elif fid == 2:
7677 
        if ftype == TType.I32:
7678 
          self.itemStatus = iprot.readI32();
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      else:
7682 
        iprot.skip(ftype)
7683 
      iprot.readFieldEnd()
7684 
    iprot.readStructEnd()
7685 
 
7686 
  def write(self, oprot):
7687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7689 
      return
7690 
    oprot.writeStructBegin('getItemCountByStatus_args')
7691 
    if self.useStatus is not None:
7692 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7693 
      oprot.writeBool(self.useStatus)
7694 
      oprot.writeFieldEnd()
7695 
    if self.itemStatus is not None:
7696 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7697 
      oprot.writeI32(self.itemStatus)
7698 
      oprot.writeFieldEnd()
7699 
    oprot.writeFieldStop()
7700 
    oprot.writeStructEnd()
7701 
 
7702 
  def validate(self):
7703 
    return
7704 
 
7705 
 
7706 
  def __repr__(self):
7707 
    L = ['%s=%r' % (key, value)
7708 
      for key, value in self.__dict__.iteritems()]
7709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7710 
 
7711 
  def __eq__(self, other):
7712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7713 
 
7714 
  def __ne__(self, other):
7715 
    return not (self == other)
7716 
 
7717 
class getItemCountByStatus_result:
7718 
  """
7719 
  Attributes:
7720 
   - success
7721 
  """
7722 
 
7723 
  thrift_spec = (
7724 
    (0, TType.I32, 'success', None, None, ), # 0
7725 
  )
7726 
 
7727 
  def __init__(self, success=None,):
7728 
    self.success = success
7729 
 
7730 
  def read(self, iprot):
7731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7733 
      return
7734 
    iprot.readStructBegin()
7735 
    while True:
7736 
      (fname, ftype, fid) = iprot.readFieldBegin()
7737 
      if ftype == TType.STOP:
7738 
        break
7739 
      if fid == 0:
7740 
        if ftype == TType.I32:
7741 
          self.success = iprot.readI32();
7742 
        else:
7743 
          iprot.skip(ftype)
7744 
      else:
7745 
        iprot.skip(ftype)
7746 
      iprot.readFieldEnd()
7747 
    iprot.readStructEnd()
7748 
 
7749 
  def write(self, oprot):
7750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7752 
      return
7753 
    oprot.writeStructBegin('getItemCountByStatus_result')
7754 
    if self.success is not None:
7755 
      oprot.writeFieldBegin('success', TType.I32, 0)
7756 
      oprot.writeI32(self.success)
7757 
      oprot.writeFieldEnd()
7758 
    oprot.writeFieldStop()
7759 
    oprot.writeStructEnd()
7760 
 
7761 
  def validate(self):
7762 
    return
7763 
 
7764 
 
7765 
  def __repr__(self):
7766 
    L = ['%s=%r' % (key, value)
7767 
      for key, value in self.__dict__.iteritems()]
7768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7769 
 
7770 
  def __eq__(self, other):
7771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7772 
 
7773 
  def __ne__(self, other):
7774 
    return not (self == other)
7775 
 
7776 
class getBestSellers_args:
7777 
 
7778 
  thrift_spec = (
7779 
  )
7780 
 
7781 
  def read(self, iprot):
7782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7784 
      return
7785 
    iprot.readStructBegin()
7786 
    while True:
7787 
      (fname, ftype, fid) = iprot.readFieldBegin()
7788 
      if ftype == TType.STOP:
7789 
        break
7790 
      else:
7791 
        iprot.skip(ftype)
7792 
      iprot.readFieldEnd()
7793 
    iprot.readStructEnd()
7794 
 
7795 
  def write(self, oprot):
7796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7798 
      return
7799 
    oprot.writeStructBegin('getBestSellers_args')
7800 
    oprot.writeFieldStop()
7801 
    oprot.writeStructEnd()
7802 
 
7803 
  def validate(self):
7804 
    return
7805 
 
7806 
 
7807 
  def __repr__(self):
7808 
    L = ['%s=%r' % (key, value)
7809 
      for key, value in self.__dict__.iteritems()]
7810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7811 
 
7812 
  def __eq__(self, other):
7813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7814 
 
7815 
  def __ne__(self, other):
7816 
    return not (self == other)
7817 
 
7818 
class getBestSellers_result:
7819 
  """
7820 
  Attributes:
7821 
   - success
7822 
   - isex
7823 
  """
7824 
 
7825 
  thrift_spec = (
7826 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7827 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7828 
  )
7829 
 
7830 
  def __init__(self, success=None, isex=None,):
7831 
    self.success = success
7832 
    self.isex = isex
7833 
 
7834 
  def read(self, iprot):
7835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7837 
      return
7838 
    iprot.readStructBegin()
7839 
    while True:
7840 
      (fname, ftype, fid) = iprot.readFieldBegin()
7841 
      if ftype == TType.STOP:
7842 
        break
7843 
      if fid == 0:
7844 
        if ftype == TType.LIST:
7845 
          self.success = []
7438 amit.gupta 7846 
          (_etype77, _size74) = iprot.readListBegin()
7847 
          for _i78 in xrange(_size74):
7848 
            _elem79 = Item()
7849 
            _elem79.read(iprot)
7850 
            self.success.append(_elem79)
5944 mandeep.dh 7851 
          iprot.readListEnd()
7852 
        else:
7853 
          iprot.skip(ftype)
7854 
      elif fid == 1:
7855 
        if ftype == TType.STRUCT:
7856 
          self.isex = CatalogServiceException()
7857 
          self.isex.read(iprot)
7858 
        else:
7859 
          iprot.skip(ftype)
7860 
      else:
7861 
        iprot.skip(ftype)
7862 
      iprot.readFieldEnd()
7863 
    iprot.readStructEnd()
7864 
 
7865 
  def write(self, oprot):
7866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7868 
      return
7869 
    oprot.writeStructBegin('getBestSellers_result')
7870 
    if self.success is not None:
7871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7873 
      for iter80 in self.success:
7874 
        iter80.write(oprot)
5944 mandeep.dh 7875 
      oprot.writeListEnd()
7876 
      oprot.writeFieldEnd()
7877 
    if self.isex is not None:
7878 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7879 
      self.isex.write(oprot)
7880 
      oprot.writeFieldEnd()
7881 
    oprot.writeFieldStop()
7882 
    oprot.writeStructEnd()
7883 
 
7884 
  def validate(self):
7885 
    return
7886 
 
7887 
 
7888 
  def __repr__(self):
7889 
    L = ['%s=%r' % (key, value)
7890 
      for key, value in self.__dict__.iteritems()]
7891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7892 
 
7893 
  def __eq__(self, other):
7894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7895 
 
7896 
  def __ne__(self, other):
7897 
    return not (self == other)
7898 
 
7899 
class getBestSellersCatalogIds_args:
7900 
  """
7901 
  Attributes:
7902 
   - beginIndex
7903 
   - totalItems
7904 
   - brand
7905 
   - category
7906 
  """
7907 
 
7908 
  thrift_spec = (
7909 
    None, # 0
7910 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7911 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7912 
    (3, TType.STRING, 'brand', None, None, ), # 3
7913 
    (4, TType.I64, 'category', None, None, ), # 4
7914 
  )
7915 
 
7916 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7917 
    self.beginIndex = beginIndex
7918 
    self.totalItems = totalItems
7919 
    self.brand = brand
7920 
    self.category = category
7921 
 
7922 
  def read(self, iprot):
7923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7925 
      return
7926 
    iprot.readStructBegin()
7927 
    while True:
7928 
      (fname, ftype, fid) = iprot.readFieldBegin()
7929 
      if ftype == TType.STOP:
7930 
        break
7931 
      if fid == 1:
7932 
        if ftype == TType.I64:
7933 
          self.beginIndex = iprot.readI64();
7934 
        else:
7935 
          iprot.skip(ftype)
7936 
      elif fid == 2:
7937 
        if ftype == TType.I64:
7938 
          self.totalItems = iprot.readI64();
7939 
        else:
7940 
          iprot.skip(ftype)
7941 
      elif fid == 3:
7942 
        if ftype == TType.STRING:
7943 
          self.brand = iprot.readString();
7944 
        else:
7945 
          iprot.skip(ftype)
7946 
      elif fid == 4:
7947 
        if ftype == TType.I64:
7948 
          self.category = iprot.readI64();
7949 
        else:
7950 
          iprot.skip(ftype)
7951 
      else:
7952 
        iprot.skip(ftype)
7953 
      iprot.readFieldEnd()
7954 
    iprot.readStructEnd()
7955 
 
7956 
  def write(self, oprot):
7957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7959 
      return
7960 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7961 
    if self.beginIndex is not None:
7962 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7963 
      oprot.writeI64(self.beginIndex)
7964 
      oprot.writeFieldEnd()
7965 
    if self.totalItems is not None:
7966 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7967 
      oprot.writeI64(self.totalItems)
7968 
      oprot.writeFieldEnd()
7969 
    if self.brand is not None:
7970 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7971 
      oprot.writeString(self.brand)
7972 
      oprot.writeFieldEnd()
7973 
    if self.category is not None:
7974 
      oprot.writeFieldBegin('category', TType.I64, 4)
7975 
      oprot.writeI64(self.category)
7976 
      oprot.writeFieldEnd()
7977 
    oprot.writeFieldStop()
7978 
    oprot.writeStructEnd()
7979 
 
7980 
  def validate(self):
7981 
    return
7982 
 
7983 
 
7984 
  def __repr__(self):
7985 
    L = ['%s=%r' % (key, value)
7986 
      for key, value in self.__dict__.iteritems()]
7987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7988 
 
7989 
  def __eq__(self, other):
7990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7991 
 
7992 
  def __ne__(self, other):
7993 
    return not (self == other)
7994 
 
7995 
class getBestSellersCatalogIds_result:
7996 
  """
7997 
  Attributes:
7998 
   - success
7999 
   - cex
8000 
  """
8001 
 
8002 
  thrift_spec = (
8003 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8004 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8005 
  )
8006 
 
8007 
  def __init__(self, success=None, cex=None,):
8008 
    self.success = success
8009 
    self.cex = cex
8010 
 
8011 
  def read(self, iprot):
8012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8014 
      return
8015 
    iprot.readStructBegin()
8016 
    while True:
8017 
      (fname, ftype, fid) = iprot.readFieldBegin()
8018 
      if ftype == TType.STOP:
8019 
        break
8020 
      if fid == 0:
8021 
        if ftype == TType.LIST:
8022 
          self.success = []
7438 amit.gupta 8023 
          (_etype84, _size81) = iprot.readListBegin()
8024 
          for _i85 in xrange(_size81):
8025 
            _elem86 = iprot.readI64();
8026 
            self.success.append(_elem86)
5944 mandeep.dh 8027 
          iprot.readListEnd()
8028 
        else:
8029 
          iprot.skip(ftype)
8030 
      elif fid == 1:
8031 
        if ftype == TType.STRUCT:
8032 
          self.cex = CatalogServiceException()
8033 
          self.cex.read(iprot)
8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      else:
8037 
        iprot.skip(ftype)
8038 
      iprot.readFieldEnd()
8039 
    iprot.readStructEnd()
8040 
 
8041 
  def write(self, oprot):
8042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8044 
      return
8045 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8046 
    if self.success is not None:
8047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8048 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8049 
      for iter87 in self.success:
8050 
        oprot.writeI64(iter87)
5944 mandeep.dh 8051 
      oprot.writeListEnd()
8052 
      oprot.writeFieldEnd()
8053 
    if self.cex is not None:
8054 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8055 
      self.cex.write(oprot)
8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
8060 
  def validate(self):
8061 
    return
8062 
 
8063 
 
8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
8075 
class getBestSellersCount_args:
8076 
 
8077 
  thrift_spec = (
8078 
  )
8079 
 
8080 
  def read(self, iprot):
8081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8083 
      return
8084 
    iprot.readStructBegin()
8085 
    while True:
8086 
      (fname, ftype, fid) = iprot.readFieldBegin()
8087 
      if ftype == TType.STOP:
8088 
        break
8089 
      else:
8090 
        iprot.skip(ftype)
8091 
      iprot.readFieldEnd()
8092 
    iprot.readStructEnd()
8093 
 
8094 
  def write(self, oprot):
8095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8097 
      return
8098 
    oprot.writeStructBegin('getBestSellersCount_args')
8099 
    oprot.writeFieldStop()
8100 
    oprot.writeStructEnd()
8101 
 
8102 
  def validate(self):
8103 
    return
8104 
 
8105 
 
8106 
  def __repr__(self):
8107 
    L = ['%s=%r' % (key, value)
8108 
      for key, value in self.__dict__.iteritems()]
8109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8110 
 
8111 
  def __eq__(self, other):
8112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8113 
 
8114 
  def __ne__(self, other):
8115 
    return not (self == other)
8116 
 
8117 
class getBestSellersCount_result:
8118 
  """
8119 
  Attributes:
8120 
   - success
8121 
   - cex
8122 
  """
8123 
 
8124 
  thrift_spec = (
8125 
    (0, TType.I64, 'success', None, None, ), # 0
8126 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8127 
  )
8128 
 
8129 
  def __init__(self, success=None, cex=None,):
8130 
    self.success = success
8131 
    self.cex = cex
8132 
 
8133 
  def read(self, iprot):
8134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8136 
      return
8137 
    iprot.readStructBegin()
8138 
    while True:
8139 
      (fname, ftype, fid) = iprot.readFieldBegin()
8140 
      if ftype == TType.STOP:
8141 
        break
8142 
      if fid == 0:
8143 
        if ftype == TType.I64:
8144 
          self.success = iprot.readI64();
8145 
        else:
8146 
          iprot.skip(ftype)
8147 
      elif fid == 1:
8148 
        if ftype == TType.STRUCT:
8149 
          self.cex = CatalogServiceException()
8150 
          self.cex.read(iprot)
8151 
        else:
8152 
          iprot.skip(ftype)
8153 
      else:
8154 
        iprot.skip(ftype)
8155 
      iprot.readFieldEnd()
8156 
    iprot.readStructEnd()
8157 
 
8158 
  def write(self, oprot):
8159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8161 
      return
8162 
    oprot.writeStructBegin('getBestSellersCount_result')
8163 
    if self.success is not None:
8164 
      oprot.writeFieldBegin('success', TType.I64, 0)
8165 
      oprot.writeI64(self.success)
8166 
      oprot.writeFieldEnd()
8167 
    if self.cex is not None:
8168 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8169 
      self.cex.write(oprot)
8170 
      oprot.writeFieldEnd()
8171 
    oprot.writeFieldStop()
8172 
    oprot.writeStructEnd()
8173 
 
8174 
  def validate(self):
8175 
    return
8176 
 
8177 
 
8178 
  def __repr__(self):
8179 
    L = ['%s=%r' % (key, value)
8180 
      for key, value in self.__dict__.iteritems()]
8181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8182 
 
8183 
  def __eq__(self, other):
8184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8185 
 
8186 
  def __ne__(self, other):
8187 
    return not (self == other)
8188 
 
8189 
class getBestDeals_args:
8190 
 
8191 
  thrift_spec = (
8192 
  )
8193 
 
8194 
  def read(self, iprot):
8195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8197 
      return
8198 
    iprot.readStructBegin()
8199 
    while True:
8200 
      (fname, ftype, fid) = iprot.readFieldBegin()
8201 
      if ftype == TType.STOP:
8202 
        break
8203 
      else:
8204 
        iprot.skip(ftype)
8205 
      iprot.readFieldEnd()
8206 
    iprot.readStructEnd()
8207 
 
8208 
  def write(self, oprot):
8209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8211 
      return
8212 
    oprot.writeStructBegin('getBestDeals_args')
8213 
    oprot.writeFieldStop()
8214 
    oprot.writeStructEnd()
8215 
 
8216 
  def validate(self):
8217 
    return
8218 
 
8219 
 
8220 
  def __repr__(self):
8221 
    L = ['%s=%r' % (key, value)
8222 
      for key, value in self.__dict__.iteritems()]
8223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8224 
 
8225 
  def __eq__(self, other):
8226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8227 
 
8228 
  def __ne__(self, other):
8229 
    return not (self == other)
8230 
 
8231 
class getBestDeals_result:
8232 
  """
8233 
  Attributes:
8234 
   - success
8235 
   - isex
8236 
  """
8237 
 
8238 
  thrift_spec = (
8239 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8240 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8241 
  )
8242 
 
8243 
  def __init__(self, success=None, isex=None,):
8244 
    self.success = success
8245 
    self.isex = isex
8246 
 
8247 
  def read(self, iprot):
8248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8250 
      return
8251 
    iprot.readStructBegin()
8252 
    while True:
8253 
      (fname, ftype, fid) = iprot.readFieldBegin()
8254 
      if ftype == TType.STOP:
8255 
        break
8256 
      if fid == 0:
8257 
        if ftype == TType.LIST:
8258 
          self.success = []
7438 amit.gupta 8259 
          (_etype91, _size88) = iprot.readListBegin()
8260 
          for _i92 in xrange(_size88):
8261 
            _elem93 = Item()
8262 
            _elem93.read(iprot)
8263 
            self.success.append(_elem93)
5944 mandeep.dh 8264 
          iprot.readListEnd()
8265 
        else:
8266 
          iprot.skip(ftype)
8267 
      elif fid == 1:
8268 
        if ftype == TType.STRUCT:
8269 
          self.isex = CatalogServiceException()
8270 
          self.isex.read(iprot)
8271 
        else:
8272 
          iprot.skip(ftype)
8273 
      else:
8274 
        iprot.skip(ftype)
8275 
      iprot.readFieldEnd()
8276 
    iprot.readStructEnd()
8277 
 
8278 
  def write(self, oprot):
8279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8281 
      return
8282 
    oprot.writeStructBegin('getBestDeals_result')
8283 
    if self.success is not None:
8284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8286 
      for iter94 in self.success:
8287 
        iter94.write(oprot)
5944 mandeep.dh 8288 
      oprot.writeListEnd()
8289 
      oprot.writeFieldEnd()
8290 
    if self.isex is not None:
8291 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8292 
      self.isex.write(oprot)
8293 
      oprot.writeFieldEnd()
8294 
    oprot.writeFieldStop()
8295 
    oprot.writeStructEnd()
8296 
 
8297 
  def validate(self):
8298 
    return
8299 
 
8300 
 
8301 
  def __repr__(self):
8302 
    L = ['%s=%r' % (key, value)
8303 
      for key, value in self.__dict__.iteritems()]
8304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8305 
 
8306 
  def __eq__(self, other):
8307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8308 
 
8309 
  def __ne__(self, other):
8310 
    return not (self == other)
8311 
 
8312 
class getBestDealsCatalogIds_args:
8313 
  """
8314 
  Attributes:
8315 
   - beginIndex
8316 
   - totalItems
8317 
   - brand
8318 
   - category
8319 
  """
8320 
 
8321 
  thrift_spec = (
8322 
    None, # 0
8323 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8324 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8325 
    (3, TType.STRING, 'brand', None, None, ), # 3
8326 
    (4, TType.I64, 'category', None, None, ), # 4
8327 
  )
8328 
 
8329 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8330 
    self.beginIndex = beginIndex
8331 
    self.totalItems = totalItems
8332 
    self.brand = brand
8333 
    self.category = category
8334 
 
8335 
  def read(self, iprot):
8336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8338 
      return
8339 
    iprot.readStructBegin()
8340 
    while True:
8341 
      (fname, ftype, fid) = iprot.readFieldBegin()
8342 
      if ftype == TType.STOP:
8343 
        break
8344 
      if fid == 1:
8345 
        if ftype == TType.I64:
8346 
          self.beginIndex = iprot.readI64();
8347 
        else:
8348 
          iprot.skip(ftype)
8349 
      elif fid == 2:
8350 
        if ftype == TType.I64:
8351 
          self.totalItems = iprot.readI64();
8352 
        else:
8353 
          iprot.skip(ftype)
8354 
      elif fid == 3:
8355 
        if ftype == TType.STRING:
8356 
          self.brand = iprot.readString();
8357 
        else:
8358 
          iprot.skip(ftype)
8359 
      elif fid == 4:
8360 
        if ftype == TType.I64:
8361 
          self.category = iprot.readI64();
8362 
        else:
8363 
          iprot.skip(ftype)
8364 
      else:
8365 
        iprot.skip(ftype)
8366 
      iprot.readFieldEnd()
8367 
    iprot.readStructEnd()
8368 
 
8369 
  def write(self, oprot):
8370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8372 
      return
8373 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8374 
    if self.beginIndex is not None:
8375 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8376 
      oprot.writeI64(self.beginIndex)
8377 
      oprot.writeFieldEnd()
8378 
    if self.totalItems is not None:
8379 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8380 
      oprot.writeI64(self.totalItems)
8381 
      oprot.writeFieldEnd()
8382 
    if self.brand is not None:
8383 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8384 
      oprot.writeString(self.brand)
8385 
      oprot.writeFieldEnd()
8386 
    if self.category is not None:
8387 
      oprot.writeFieldBegin('category', TType.I64, 4)
8388 
      oprot.writeI64(self.category)
8389 
      oprot.writeFieldEnd()
8390 
    oprot.writeFieldStop()
8391 
    oprot.writeStructEnd()
8392 
 
8393 
  def validate(self):
8394 
    return
8395 
 
8396 
 
8397 
  def __repr__(self):
8398 
    L = ['%s=%r' % (key, value)
8399 
      for key, value in self.__dict__.iteritems()]
8400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8401 
 
8402 
  def __eq__(self, other):
8403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8404 
 
8405 
  def __ne__(self, other):
8406 
    return not (self == other)
8407 
 
8408 
class getBestDealsCatalogIds_result:
8409 
  """
8410 
  Attributes:
8411 
   - success
8412 
   - cex
8413 
  """
8414 
 
8415 
  thrift_spec = (
8416 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8417 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8418 
  )
8419 
 
8420 
  def __init__(self, success=None, cex=None,):
8421 
    self.success = success
8422 
    self.cex = cex
8423 
 
8424 
  def read(self, iprot):
8425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8427 
      return
8428 
    iprot.readStructBegin()
8429 
    while True:
8430 
      (fname, ftype, fid) = iprot.readFieldBegin()
8431 
      if ftype == TType.STOP:
8432 
        break
8433 
      if fid == 0:
8434 
        if ftype == TType.LIST:
8435 
          self.success = []
7438 amit.gupta 8436 
          (_etype98, _size95) = iprot.readListBegin()
8437 
          for _i99 in xrange(_size95):
8438 
            _elem100 = iprot.readI64();
8439 
            self.success.append(_elem100)
5944 mandeep.dh 8440 
          iprot.readListEnd()
8441 
        else:
8442 
          iprot.skip(ftype)
8443 
      elif fid == 1:
8444 
        if ftype == TType.STRUCT:
8445 
          self.cex = CatalogServiceException()
8446 
          self.cex.read(iprot)
8447 
        else:
8448 
          iprot.skip(ftype)
8449 
      else:
8450 
        iprot.skip(ftype)
8451 
      iprot.readFieldEnd()
8452 
    iprot.readStructEnd()
8453 
 
8454 
  def write(self, oprot):
8455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8457 
      return
8458 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8459 
    if self.success is not None:
8460 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8461 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8462 
      for iter101 in self.success:
8463 
        oprot.writeI64(iter101)
5944 mandeep.dh 8464 
      oprot.writeListEnd()
8465 
      oprot.writeFieldEnd()
8466 
    if self.cex is not None:
8467 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8468 
      self.cex.write(oprot)
8469 
      oprot.writeFieldEnd()
8470 
    oprot.writeFieldStop()
8471 
    oprot.writeStructEnd()
8472 
 
8473 
  def validate(self):
8474 
    return
8475 
 
8476 
 
8477 
  def __repr__(self):
8478 
    L = ['%s=%r' % (key, value)
8479 
      for key, value in self.__dict__.iteritems()]
8480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8481 
 
8482 
  def __eq__(self, other):
8483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8484 
 
8485 
  def __ne__(self, other):
8486 
    return not (self == other)
8487 
 
8488 
class getBestDealsCount_args:
8489 
 
8490 
  thrift_spec = (
8491 
  )
8492 
 
8493 
  def read(self, iprot):
8494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8496 
      return
8497 
    iprot.readStructBegin()
8498 
    while True:
8499 
      (fname, ftype, fid) = iprot.readFieldBegin()
8500 
      if ftype == TType.STOP:
8501 
        break
8502 
      else:
8503 
        iprot.skip(ftype)
8504 
      iprot.readFieldEnd()
8505 
    iprot.readStructEnd()
8506 
 
8507 
  def write(self, oprot):
8508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8510 
      return
8511 
    oprot.writeStructBegin('getBestDealsCount_args')
8512 
    oprot.writeFieldStop()
8513 
    oprot.writeStructEnd()
8514 
 
8515 
  def validate(self):
8516 
    return
8517 
 
8518 
 
8519 
  def __repr__(self):
8520 
    L = ['%s=%r' % (key, value)
8521 
      for key, value in self.__dict__.iteritems()]
8522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8523 
 
8524 
  def __eq__(self, other):
8525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8526 
 
8527 
  def __ne__(self, other):
8528 
    return not (self == other)
8529 
 
8530 
class getBestDealsCount_result:
8531 
  """
8532 
  Attributes:
8533 
   - success
8534 
   - cex
8535 
  """
8536 
 
8537 
  thrift_spec = (
8538 
    (0, TType.I64, 'success', None, None, ), # 0
8539 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8540 
  )
8541 
 
8542 
  def __init__(self, success=None, cex=None,):
8543 
    self.success = success
8544 
    self.cex = cex
8545 
 
8546 
  def read(self, iprot):
8547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8549 
      return
8550 
    iprot.readStructBegin()
8551 
    while True:
8552 
      (fname, ftype, fid) = iprot.readFieldBegin()
8553 
      if ftype == TType.STOP:
8554 
        break
8555 
      if fid == 0:
8556 
        if ftype == TType.I64:
8557 
          self.success = iprot.readI64();
8558 
        else:
8559 
          iprot.skip(ftype)
8560 
      elif fid == 1:
8561 
        if ftype == TType.STRUCT:
8562 
          self.cex = CatalogServiceException()
8563 
          self.cex.read(iprot)
8564 
        else:
8565 
          iprot.skip(ftype)
8566 
      else:
8567 
        iprot.skip(ftype)
8568 
      iprot.readFieldEnd()
8569 
    iprot.readStructEnd()
8570 
 
8571 
  def write(self, oprot):
8572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8574 
      return
8575 
    oprot.writeStructBegin('getBestDealsCount_result')
8576 
    if self.success is not None:
8577 
      oprot.writeFieldBegin('success', TType.I64, 0)
8578 
      oprot.writeI64(self.success)
8579 
      oprot.writeFieldEnd()
8580 
    if self.cex is not None:
8581 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8582 
      self.cex.write(oprot)
8583 
      oprot.writeFieldEnd()
8584 
    oprot.writeFieldStop()
8585 
    oprot.writeStructEnd()
8586 
 
8587 
  def validate(self):
8588 
    return
8589 
 
8590 
 
8591 
  def __repr__(self):
8592 
    L = ['%s=%r' % (key, value)
8593 
      for key, value in self.__dict__.iteritems()]
8594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8595 
 
8596 
  def __eq__(self, other):
8597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8598 
 
8599 
  def __ne__(self, other):
8600 
    return not (self == other)
8601 
 
8602 
class getComingSoon_args:
8603 
 
8604 
  thrift_spec = (
8605 
  )
8606 
 
8607 
  def read(self, iprot):
8608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8610 
      return
8611 
    iprot.readStructBegin()
8612 
    while True:
8613 
      (fname, ftype, fid) = iprot.readFieldBegin()
8614 
      if ftype == TType.STOP:
8615 
        break
8616 
      else:
8617 
        iprot.skip(ftype)
8618 
      iprot.readFieldEnd()
8619 
    iprot.readStructEnd()
8620 
 
8621 
  def write(self, oprot):
8622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8624 
      return
8625 
    oprot.writeStructBegin('getComingSoon_args')
8626 
    oprot.writeFieldStop()
8627 
    oprot.writeStructEnd()
8628 
 
8629 
  def validate(self):
8630 
    return
8631 
 
8632 
 
8633 
  def __repr__(self):
8634 
    L = ['%s=%r' % (key, value)
8635 
      for key, value in self.__dict__.iteritems()]
8636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8637 
 
8638 
  def __eq__(self, other):
8639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8640 
 
8641 
  def __ne__(self, other):
8642 
    return not (self == other)
8643 
 
8644 
class getComingSoon_result:
8645 
  """
8646 
  Attributes:
8647 
   - success
8648 
   - isex
8649 
  """
8650 
 
8651 
  thrift_spec = (
8652 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8653 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8654 
  )
8655 
 
8656 
  def __init__(self, success=None, isex=None,):
8657 
    self.success = success
8658 
    self.isex = isex
8659 
 
8660 
  def read(self, iprot):
8661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8663 
      return
8664 
    iprot.readStructBegin()
8665 
    while True:
8666 
      (fname, ftype, fid) = iprot.readFieldBegin()
8667 
      if ftype == TType.STOP:
8668 
        break
8669 
      if fid == 0:
8670 
        if ftype == TType.LIST:
8671 
          self.success = []
7438 amit.gupta 8672 
          (_etype105, _size102) = iprot.readListBegin()
8673 
          for _i106 in xrange(_size102):
8674 
            _elem107 = Item()
8675 
            _elem107.read(iprot)
8676 
            self.success.append(_elem107)
5944 mandeep.dh 8677 
          iprot.readListEnd()
8678 
        else:
8679 
          iprot.skip(ftype)
8680 
      elif fid == 1:
8681 
        if ftype == TType.STRUCT:
8682 
          self.isex = CatalogServiceException()
8683 
          self.isex.read(iprot)
8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      else:
8687 
        iprot.skip(ftype)
8688 
      iprot.readFieldEnd()
8689 
    iprot.readStructEnd()
8690 
 
8691 
  def write(self, oprot):
8692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8694 
      return
8695 
    oprot.writeStructBegin('getComingSoon_result')
8696 
    if self.success is not None:
8697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8699 
      for iter108 in self.success:
8700 
        iter108.write(oprot)
5944 mandeep.dh 8701 
      oprot.writeListEnd()
8702 
      oprot.writeFieldEnd()
8703 
    if self.isex is not None:
8704 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8705 
      self.isex.write(oprot)
8706 
      oprot.writeFieldEnd()
8707 
    oprot.writeFieldStop()
8708 
    oprot.writeStructEnd()
8709 
 
8710 
  def validate(self):
8711 
    return
8712 
 
8713 
 
8714 
  def __repr__(self):
8715 
    L = ['%s=%r' % (key, value)
8716 
      for key, value in self.__dict__.iteritems()]
8717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8718 
 
8719 
  def __eq__(self, other):
8720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8721 
 
8722 
  def __ne__(self, other):
8723 
    return not (self == other)
8724 
 
8725 
class getComingSoonCatalogIds_args:
8726 
  """
8727 
  Attributes:
8728 
   - beginIndex
8729 
   - totalItems
8730 
   - brand
8731 
   - category
8732 
  """
8733 
 
8734 
  thrift_spec = (
8735 
    None, # 0
8736 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8737 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8738 
    (3, TType.STRING, 'brand', None, None, ), # 3
8739 
    (4, TType.I64, 'category', None, None, ), # 4
8740 
  )
8741 
 
8742 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8743 
    self.beginIndex = beginIndex
8744 
    self.totalItems = totalItems
8745 
    self.brand = brand
8746 
    self.category = category
8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 1:
8758 
        if ftype == TType.I64:
8759 
          self.beginIndex = iprot.readI64();
8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      elif fid == 2:
8763 
        if ftype == TType.I64:
8764 
          self.totalItems = iprot.readI64();
8765 
        else:
8766 
          iprot.skip(ftype)
8767 
      elif fid == 3:
8768 
        if ftype == TType.STRING:
8769 
          self.brand = iprot.readString();
8770 
        else:
8771 
          iprot.skip(ftype)
8772 
      elif fid == 4:
8773 
        if ftype == TType.I64:
8774 
          self.category = iprot.readI64();
8775 
        else:
8776 
          iprot.skip(ftype)
8777 
      else:
8778 
        iprot.skip(ftype)
8779 
      iprot.readFieldEnd()
8780 
    iprot.readStructEnd()
8781 
 
8782 
  def write(self, oprot):
8783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8785 
      return
8786 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8787 
    if self.beginIndex is not None:
8788 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8789 
      oprot.writeI64(self.beginIndex)
8790 
      oprot.writeFieldEnd()
8791 
    if self.totalItems is not None:
8792 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8793 
      oprot.writeI64(self.totalItems)
8794 
      oprot.writeFieldEnd()
8795 
    if self.brand is not None:
8796 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8797 
      oprot.writeString(self.brand)
8798 
      oprot.writeFieldEnd()
8799 
    if self.category is not None:
8800 
      oprot.writeFieldBegin('category', TType.I64, 4)
8801 
      oprot.writeI64(self.category)
8802 
      oprot.writeFieldEnd()
8803 
    oprot.writeFieldStop()
8804 
    oprot.writeStructEnd()
8805 
 
8806 
  def validate(self):
8807 
    return
8808 
 
8809 
 
8810 
  def __repr__(self):
8811 
    L = ['%s=%r' % (key, value)
8812 
      for key, value in self.__dict__.iteritems()]
8813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8814 
 
8815 
  def __eq__(self, other):
8816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8817 
 
8818 
  def __ne__(self, other):
8819 
    return not (self == other)
8820 
 
8821 
class getComingSoonCatalogIds_result:
8822 
  """
8823 
  Attributes:
8824 
   - success
8825 
   - cex
8826 
  """
8827 
 
8828 
  thrift_spec = (
8829 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8830 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8831 
  )
8832 
 
8833 
  def __init__(self, success=None, cex=None,):
8834 
    self.success = success
8835 
    self.cex = cex
8836 
 
8837 
  def read(self, iprot):
8838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8840 
      return
8841 
    iprot.readStructBegin()
8842 
    while True:
8843 
      (fname, ftype, fid) = iprot.readFieldBegin()
8844 
      if ftype == TType.STOP:
8845 
        break
8846 
      if fid == 0:
8847 
        if ftype == TType.LIST:
8848 
          self.success = []
7438 amit.gupta 8849 
          (_etype112, _size109) = iprot.readListBegin()
8850 
          for _i113 in xrange(_size109):
8851 
            _elem114 = iprot.readI64();
8852 
            self.success.append(_elem114)
5944 mandeep.dh 8853 
          iprot.readListEnd()
8854 
        else:
8855 
          iprot.skip(ftype)
8856 
      elif fid == 1:
8857 
        if ftype == TType.STRUCT:
8858 
          self.cex = CatalogServiceException()
8859 
          self.cex.read(iprot)
8860 
        else:
8861 
          iprot.skip(ftype)
8862 
      else:
8863 
        iprot.skip(ftype)
8864 
      iprot.readFieldEnd()
8865 
    iprot.readStructEnd()
8866 
 
8867 
  def write(self, oprot):
8868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8870 
      return
8871 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8872 
    if self.success is not None:
8873 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8874 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8875 
      for iter115 in self.success:
8876 
        oprot.writeI64(iter115)
5944 mandeep.dh 8877 
      oprot.writeListEnd()
8878 
      oprot.writeFieldEnd()
8879 
    if self.cex is not None:
8880 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8881 
      self.cex.write(oprot)
8882 
      oprot.writeFieldEnd()
8883 
    oprot.writeFieldStop()
8884 
    oprot.writeStructEnd()
8885 
 
8886 
  def validate(self):
8887 
    return
8888 
 
8889 
 
8890 
  def __repr__(self):
8891 
    L = ['%s=%r' % (key, value)
8892 
      for key, value in self.__dict__.iteritems()]
8893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8894 
 
8895 
  def __eq__(self, other):
8896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8897 
 
8898 
  def __ne__(self, other):
8899 
    return not (self == other)
8900 
 
8901 
class getComingSoonCount_args:
8902 
 
8903 
  thrift_spec = (
8904 
  )
8905 
 
8906 
  def read(self, iprot):
8907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8909 
      return
8910 
    iprot.readStructBegin()
8911 
    while True:
8912 
      (fname, ftype, fid) = iprot.readFieldBegin()
8913 
      if ftype == TType.STOP:
8914 
        break
8915 
      else:
8916 
        iprot.skip(ftype)
8917 
      iprot.readFieldEnd()
8918 
    iprot.readStructEnd()
8919 
 
8920 
  def write(self, oprot):
8921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8923 
      return
8924 
    oprot.writeStructBegin('getComingSoonCount_args')
8925 
    oprot.writeFieldStop()
8926 
    oprot.writeStructEnd()
8927 
 
8928 
  def validate(self):
8929 
    return
8930 
 
8931 
 
8932 
  def __repr__(self):
8933 
    L = ['%s=%r' % (key, value)
8934 
      for key, value in self.__dict__.iteritems()]
8935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8936 
 
8937 
  def __eq__(self, other):
8938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8939 
 
8940 
  def __ne__(self, other):
8941 
    return not (self == other)
8942 
 
8943 
class getComingSoonCount_result:
8944 
  """
8945 
  Attributes:
8946 
   - success
8947 
   - cex
8948 
  """
8949 
 
8950 
  thrift_spec = (
8951 
    (0, TType.I64, 'success', None, None, ), # 0
8952 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8953 
  )
8954 
 
8955 
  def __init__(self, success=None, cex=None,):
8956 
    self.success = success
8957 
    self.cex = cex
8958 
 
8959 
  def read(self, iprot):
8960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8962 
      return
8963 
    iprot.readStructBegin()
8964 
    while True:
8965 
      (fname, ftype, fid) = iprot.readFieldBegin()
8966 
      if ftype == TType.STOP:
8967 
        break
8968 
      if fid == 0:
8969 
        if ftype == TType.I64:
8970 
          self.success = iprot.readI64();
8971 
        else:
8972 
          iprot.skip(ftype)
8973 
      elif fid == 1:
8974 
        if ftype == TType.STRUCT:
8975 
          self.cex = CatalogServiceException()
8976 
          self.cex.read(iprot)
8977 
        else:
8978 
          iprot.skip(ftype)
8979 
      else:
8980 
        iprot.skip(ftype)
8981 
      iprot.readFieldEnd()
8982 
    iprot.readStructEnd()
8983 
 
8984 
  def write(self, oprot):
8985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8987 
      return
8988 
    oprot.writeStructBegin('getComingSoonCount_result')
8989 
    if self.success is not None:
8990 
      oprot.writeFieldBegin('success', TType.I64, 0)
8991 
      oprot.writeI64(self.success)
8992 
      oprot.writeFieldEnd()
8993 
    if self.cex is not None:
8994 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8995 
      self.cex.write(oprot)
8996 
      oprot.writeFieldEnd()
8997 
    oprot.writeFieldStop()
8998 
    oprot.writeStructEnd()
8999 
 
9000 
  def validate(self):
9001 
    return
9002 
 
9003 
 
9004 
  def __repr__(self):
9005 
    L = ['%s=%r' % (key, value)
9006 
      for key, value in self.__dict__.iteritems()]
9007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9008 
 
9009 
  def __eq__(self, other):
9010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9011 
 
9012 
  def __ne__(self, other):
9013 
    return not (self == other)
9014 
 
9015 
class getLatestArrivals_args:
9016 
 
9017 
  thrift_spec = (
9018 
  )
9019 
 
9020 
  def read(self, iprot):
9021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9023 
      return
9024 
    iprot.readStructBegin()
9025 
    while True:
9026 
      (fname, ftype, fid) = iprot.readFieldBegin()
9027 
      if ftype == TType.STOP:
9028 
        break
9029 
      else:
9030 
        iprot.skip(ftype)
9031 
      iprot.readFieldEnd()
9032 
    iprot.readStructEnd()
9033 
 
9034 
  def write(self, oprot):
9035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9037 
      return
9038 
    oprot.writeStructBegin('getLatestArrivals_args')
9039 
    oprot.writeFieldStop()
9040 
    oprot.writeStructEnd()
9041 
 
9042 
  def validate(self):
9043 
    return
9044 
 
9045 
 
9046 
  def __repr__(self):
9047 
    L = ['%s=%r' % (key, value)
9048 
      for key, value in self.__dict__.iteritems()]
9049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9050 
 
9051 
  def __eq__(self, other):
9052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9053 
 
9054 
  def __ne__(self, other):
9055 
    return not (self == other)
9056 
 
9057 
class getLatestArrivals_result:
9058 
  """
9059 
  Attributes:
9060 
   - success
9061 
   - isex
9062 
  """
9063 
 
9064 
  thrift_spec = (
9065 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9066 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9067 
  )
9068 
 
9069 
  def __init__(self, success=None, isex=None,):
9070 
    self.success = success
9071 
    self.isex = isex
9072 
 
9073 
  def read(self, iprot):
9074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9076 
      return
9077 
    iprot.readStructBegin()
9078 
    while True:
9079 
      (fname, ftype, fid) = iprot.readFieldBegin()
9080 
      if ftype == TType.STOP:
9081 
        break
9082 
      if fid == 0:
9083 
        if ftype == TType.LIST:
9084 
          self.success = []
7438 amit.gupta 9085 
          (_etype119, _size116) = iprot.readListBegin()
9086 
          for _i120 in xrange(_size116):
9087 
            _elem121 = Item()
9088 
            _elem121.read(iprot)
9089 
            self.success.append(_elem121)
5944 mandeep.dh 9090 
          iprot.readListEnd()
9091 
        else:
9092 
          iprot.skip(ftype)
9093 
      elif fid == 1:
9094 
        if ftype == TType.STRUCT:
9095 
          self.isex = CatalogServiceException()
9096 
          self.isex.read(iprot)
9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      else:
9100 
        iprot.skip(ftype)
9101 
      iprot.readFieldEnd()
9102 
    iprot.readStructEnd()
9103 
 
9104 
  def write(self, oprot):
9105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9107 
      return
9108 
    oprot.writeStructBegin('getLatestArrivals_result')
9109 
    if self.success is not None:
9110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9112 
      for iter122 in self.success:
9113 
        iter122.write(oprot)
5944 mandeep.dh 9114 
      oprot.writeListEnd()
9115 
      oprot.writeFieldEnd()
9116 
    if self.isex is not None:
9117 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9118 
      self.isex.write(oprot)
9119 
      oprot.writeFieldEnd()
9120 
    oprot.writeFieldStop()
9121 
    oprot.writeStructEnd()
9122 
 
9123 
  def validate(self):
9124 
    return
9125 
 
9126 
 
9127 
  def __repr__(self):
9128 
    L = ['%s=%r' % (key, value)
9129 
      for key, value in self.__dict__.iteritems()]
9130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9131 
 
9132 
  def __eq__(self, other):
9133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9134 
 
9135 
  def __ne__(self, other):
9136 
    return not (self == other)
9137 
 
9138 
class getLatestArrivalsCatalogIds_args:
9139 
  """
9140 
  Attributes:
9141 
   - beginIndex
9142 
   - totalItems
9143 
   - brand
9144 
   - categories
9145 
  """
9146 
 
9147 
  thrift_spec = (
9148 
    None, # 0
9149 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9150 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9151 
    (3, TType.STRING, 'brand', None, None, ), # 3
9152 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9153 
  )
9154 
 
9155 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9156 
    self.beginIndex = beginIndex
9157 
    self.totalItems = totalItems
9158 
    self.brand = brand
9159 
    self.categories = categories
9160 
 
9161 
  def read(self, iprot):
9162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9164 
      return
9165 
    iprot.readStructBegin()
9166 
    while True:
9167 
      (fname, ftype, fid) = iprot.readFieldBegin()
9168 
      if ftype == TType.STOP:
9169 
        break
9170 
      if fid == 1:
9171 
        if ftype == TType.I64:
9172 
          self.beginIndex = iprot.readI64();
9173 
        else:
9174 
          iprot.skip(ftype)
9175 
      elif fid == 2:
9176 
        if ftype == TType.I64:
9177 
          self.totalItems = iprot.readI64();
9178 
        else:
9179 
          iprot.skip(ftype)
9180 
      elif fid == 3:
9181 
        if ftype == TType.STRING:
9182 
          self.brand = iprot.readString();
9183 
        else:
9184 
          iprot.skip(ftype)
9185 
      elif fid == 4:
9186 
        if ftype == TType.LIST:
9187 
          self.categories = []
7438 amit.gupta 9188 
          (_etype126, _size123) = iprot.readListBegin()
9189 
          for _i127 in xrange(_size123):
9190 
            _elem128 = iprot.readI64();
9191 
            self.categories.append(_elem128)
5944 mandeep.dh 9192 
          iprot.readListEnd()
9193 
        else:
9194 
          iprot.skip(ftype)
9195 
      else:
9196 
        iprot.skip(ftype)
9197 
      iprot.readFieldEnd()
9198 
    iprot.readStructEnd()
9199 
 
9200 
  def write(self, oprot):
9201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9203 
      return
9204 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9205 
    if self.beginIndex is not None:
9206 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9207 
      oprot.writeI64(self.beginIndex)
9208 
      oprot.writeFieldEnd()
9209 
    if self.totalItems is not None:
9210 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9211 
      oprot.writeI64(self.totalItems)
9212 
      oprot.writeFieldEnd()
9213 
    if self.brand is not None:
9214 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9215 
      oprot.writeString(self.brand)
9216 
      oprot.writeFieldEnd()
9217 
    if self.categories is not None:
9218 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9219 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9220 
      for iter129 in self.categories:
9221 
        oprot.writeI64(iter129)
5944 mandeep.dh 9222 
      oprot.writeListEnd()
9223 
      oprot.writeFieldEnd()
9224 
    oprot.writeFieldStop()
9225 
    oprot.writeStructEnd()
9226 
 
9227 
  def validate(self):
9228 
    return
9229 
 
9230 
 
9231 
  def __repr__(self):
9232 
    L = ['%s=%r' % (key, value)
9233 
      for key, value in self.__dict__.iteritems()]
9234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9235 
 
9236 
  def __eq__(self, other):
9237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9238 
 
9239 
  def __ne__(self, other):
9240 
    return not (self == other)
9241 
 
9242 
class getLatestArrivalsCatalogIds_result:
9243 
  """
9244 
  Attributes:
9245 
   - success
9246 
   - cex
9247 
  """
9248 
 
9249 
  thrift_spec = (
9250 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9251 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9252 
  )
9253 
 
9254 
  def __init__(self, success=None, cex=None,):
9255 
    self.success = success
9256 
    self.cex = cex
9257 
 
9258 
  def read(self, iprot):
9259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9261 
      return
9262 
    iprot.readStructBegin()
9263 
    while True:
9264 
      (fname, ftype, fid) = iprot.readFieldBegin()
9265 
      if ftype == TType.STOP:
9266 
        break
9267 
      if fid == 0:
9268 
        if ftype == TType.LIST:
9269 
          self.success = []
7438 amit.gupta 9270 
          (_etype133, _size130) = iprot.readListBegin()
9271 
          for _i134 in xrange(_size130):
9272 
            _elem135 = iprot.readI64();
9273 
            self.success.append(_elem135)
5944 mandeep.dh 9274 
          iprot.readListEnd()
9275 
        else:
9276 
          iprot.skip(ftype)
9277 
      elif fid == 1:
9278 
        if ftype == TType.STRUCT:
9279 
          self.cex = CatalogServiceException()
9280 
          self.cex.read(iprot)
9281 
        else:
9282 
          iprot.skip(ftype)
9283 
      else:
9284 
        iprot.skip(ftype)
9285 
      iprot.readFieldEnd()
9286 
    iprot.readStructEnd()
9287 
 
9288 
  def write(self, oprot):
9289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9291 
      return
9292 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9293 
    if self.success is not None:
9294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9295 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9296 
      for iter136 in self.success:
9297 
        oprot.writeI64(iter136)
5944 mandeep.dh 9298 
      oprot.writeListEnd()
9299 
      oprot.writeFieldEnd()
9300 
    if self.cex is not None:
9301 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9302 
      self.cex.write(oprot)
9303 
      oprot.writeFieldEnd()
9304 
    oprot.writeFieldStop()
9305 
    oprot.writeStructEnd()
9306 
 
9307 
  def validate(self):
9308 
    return
9309 
 
9310 
 
9311 
  def __repr__(self):
9312 
    L = ['%s=%r' % (key, value)
9313 
      for key, value in self.__dict__.iteritems()]
9314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9315 
 
9316 
  def __eq__(self, other):
9317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9318 
 
9319 
  def __ne__(self, other):
9320 
    return not (self == other)
9321 
 
9322 
class getLatestArrivalsCount_args:
9323 
 
9324 
  thrift_spec = (
9325 
  )
9326 
 
9327 
  def read(self, iprot):
9328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9330 
      return
9331 
    iprot.readStructBegin()
9332 
    while True:
9333 
      (fname, ftype, fid) = iprot.readFieldBegin()
9334 
      if ftype == TType.STOP:
9335 
        break
9336 
      else:
9337 
        iprot.skip(ftype)
9338 
      iprot.readFieldEnd()
9339 
    iprot.readStructEnd()
9340 
 
9341 
  def write(self, oprot):
9342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9344 
      return
9345 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9346 
    oprot.writeFieldStop()
9347 
    oprot.writeStructEnd()
9348 
 
9349 
  def validate(self):
9350 
    return
9351 
 
9352 
 
9353 
  def __repr__(self):
9354 
    L = ['%s=%r' % (key, value)
9355 
      for key, value in self.__dict__.iteritems()]
9356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9357 
 
9358 
  def __eq__(self, other):
9359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9360 
 
9361 
  def __ne__(self, other):
9362 
    return not (self == other)
9363 
 
9364 
class getLatestArrivalsCount_result:
9365 
  """
9366 
  Attributes:
9367 
   - success
9368 
   - cex
9369 
  """
9370 
 
9371 
  thrift_spec = (
9372 
    (0, TType.I64, 'success', None, None, ), # 0
9373 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9374 
  )
9375 
 
9376 
  def __init__(self, success=None, cex=None,):
9377 
    self.success = success
9378 
    self.cex = cex
9379 
 
9380 
  def read(self, iprot):
9381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9383 
      return
9384 
    iprot.readStructBegin()
9385 
    while True:
9386 
      (fname, ftype, fid) = iprot.readFieldBegin()
9387 
      if ftype == TType.STOP:
9388 
        break
9389 
      if fid == 0:
9390 
        if ftype == TType.I64:
9391 
          self.success = iprot.readI64();
9392 
        else:
9393 
          iprot.skip(ftype)
9394 
      elif fid == 1:
9395 
        if ftype == TType.STRUCT:
9396 
          self.cex = CatalogServiceException()
9397 
          self.cex.read(iprot)
9398 
        else:
9399 
          iprot.skip(ftype)
9400 
      else:
9401 
        iprot.skip(ftype)
9402 
      iprot.readFieldEnd()
9403 
    iprot.readStructEnd()
9404 
 
9405 
  def write(self, oprot):
9406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9408 
      return
9409 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9410 
    if self.success is not None:
9411 
      oprot.writeFieldBegin('success', TType.I64, 0)
9412 
      oprot.writeI64(self.success)
9413 
      oprot.writeFieldEnd()
9414 
    if self.cex is not None:
9415 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9416 
      self.cex.write(oprot)
9417 
      oprot.writeFieldEnd()
9418 
    oprot.writeFieldStop()
9419 
    oprot.writeStructEnd()
9420 
 
9421 
  def validate(self):
9422 
    return
9423 
 
9424 
 
9425 
  def __repr__(self):
9426 
    L = ['%s=%r' % (key, value)
9427 
      for key, value in self.__dict__.iteritems()]
9428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9429 
 
9430 
  def __eq__(self, other):
9431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9432 
 
9433 
  def __ne__(self, other):
9434 
    return not (self == other)
9435 
 
9436 
class generateNewEntityID_args:
9437 
 
9438 
  thrift_spec = (
9439 
  )
9440 
 
9441 
  def read(self, iprot):
9442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9444 
      return
9445 
    iprot.readStructBegin()
9446 
    while True:
9447 
      (fname, ftype, fid) = iprot.readFieldBegin()
9448 
      if ftype == TType.STOP:
9449 
        break
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('generateNewEntityID_args')
9460 
    oprot.writeFieldStop()
9461 
    oprot.writeStructEnd()
9462 
 
9463 
  def validate(self):
9464 
    return
9465 
 
9466 
 
9467 
  def __repr__(self):
9468 
    L = ['%s=%r' % (key, value)
9469 
      for key, value in self.__dict__.iteritems()]
9470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9471 
 
9472 
  def __eq__(self, other):
9473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9474 
 
9475 
  def __ne__(self, other):
9476 
    return not (self == other)
9477 
 
9478 
class generateNewEntityID_result:
9479 
  """
9480 
  Attributes:
9481 
   - success
9482 
  """
9483 
 
9484 
  thrift_spec = (
9485 
    (0, TType.I64, 'success', None, None, ), # 0
9486 
  )
9487 
 
9488 
  def __init__(self, success=None,):
9489 
    self.success = success
9490 
 
9491 
  def read(self, iprot):
9492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9494 
      return
9495 
    iprot.readStructBegin()
9496 
    while True:
9497 
      (fname, ftype, fid) = iprot.readFieldBegin()
9498 
      if ftype == TType.STOP:
9499 
        break
9500 
      if fid == 0:
9501 
        if ftype == TType.I64:
9502 
          self.success = iprot.readI64();
9503 
        else:
9504 
          iprot.skip(ftype)
9505 
      else:
9506 
        iprot.skip(ftype)
9507 
      iprot.readFieldEnd()
9508 
    iprot.readStructEnd()
9509 
 
9510 
  def write(self, oprot):
9511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9513 
      return
9514 
    oprot.writeStructBegin('generateNewEntityID_result')
9515 
    if self.success is not None:
9516 
      oprot.writeFieldBegin('success', TType.I64, 0)
9517 
      oprot.writeI64(self.success)
9518 
      oprot.writeFieldEnd()
9519 
    oprot.writeFieldStop()
9520 
    oprot.writeStructEnd()
9521 
 
9522 
  def validate(self):
9523 
    return
9524 
 
9525 
 
9526 
  def __repr__(self):
9527 
    L = ['%s=%r' % (key, value)
9528 
      for key, value in self.__dict__.iteritems()]
9529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9530 
 
9531 
  def __eq__(self, other):
9532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9533 
 
9534 
  def __ne__(self, other):
9535 
    return not (self == other)
9536 
 
9537 
class addCategory_args:
9538 
  """
9539 
  Attributes:
9540 
   - category
9541 
  """
9542 
 
9543 
  thrift_spec = (
9544 
    None, # 0
9545 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9546 
  )
9547 
 
9548 
  def __init__(self, category=None,):
9549 
    self.category = category
9550 
 
9551 
  def read(self, iprot):
9552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9554 
      return
9555 
    iprot.readStructBegin()
9556 
    while True:
9557 
      (fname, ftype, fid) = iprot.readFieldBegin()
9558 
      if ftype == TType.STOP:
9559 
        break
9560 
      if fid == 1:
9561 
        if ftype == TType.STRUCT:
9562 
          self.category = Category()
9563 
          self.category.read(iprot)
9564 
        else:
9565 
          iprot.skip(ftype)
9566 
      else:
9567 
        iprot.skip(ftype)
9568 
      iprot.readFieldEnd()
9569 
    iprot.readStructEnd()
9570 
 
9571 
  def write(self, oprot):
9572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9574 
      return
9575 
    oprot.writeStructBegin('addCategory_args')
9576 
    if self.category is not None:
9577 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9578 
      self.category.write(oprot)
9579 
      oprot.writeFieldEnd()
9580 
    oprot.writeFieldStop()
9581 
    oprot.writeStructEnd()
9582 
 
9583 
  def validate(self):
9584 
    return
9585 
 
9586 
 
9587 
  def __repr__(self):
9588 
    L = ['%s=%r' % (key, value)
9589 
      for key, value in self.__dict__.iteritems()]
9590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9591 
 
9592 
  def __eq__(self, other):
9593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9594 
 
9595 
  def __ne__(self, other):
9596 
    return not (self == other)
9597 
 
9598 
class addCategory_result:
9599 
  """
9600 
  Attributes:
9601 
   - success
9602 
  """
9603 
 
9604 
  thrift_spec = (
9605 
    (0, TType.BOOL, 'success', None, None, ), # 0
9606 
  )
9607 
 
9608 
  def __init__(self, success=None,):
9609 
    self.success = success
9610 
 
9611 
  def read(self, iprot):
9612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9614 
      return
9615 
    iprot.readStructBegin()
9616 
    while True:
9617 
      (fname, ftype, fid) = iprot.readFieldBegin()
9618 
      if ftype == TType.STOP:
9619 
        break
9620 
      if fid == 0:
9621 
        if ftype == TType.BOOL:
9622 
          self.success = iprot.readBool();
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      else:
9626 
        iprot.skip(ftype)
9627 
      iprot.readFieldEnd()
9628 
    iprot.readStructEnd()
9629 
 
9630 
  def write(self, oprot):
9631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9633 
      return
9634 
    oprot.writeStructBegin('addCategory_result')
9635 
    if self.success is not None:
9636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9637 
      oprot.writeBool(self.success)
9638 
      oprot.writeFieldEnd()
9639 
    oprot.writeFieldStop()
9640 
    oprot.writeStructEnd()
9641 
 
9642 
  def validate(self):
9643 
    return
9644 
 
9645 
 
9646 
  def __repr__(self):
9647 
    L = ['%s=%r' % (key, value)
9648 
      for key, value in self.__dict__.iteritems()]
9649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9650 
 
9651 
  def __eq__(self, other):
9652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9653 
 
9654 
  def __ne__(self, other):
9655 
    return not (self == other)
9656 
 
9657 
class getCategory_args:
9658 
  """
9659 
  Attributes:
9660 
   - id
9661 
  """
9662 
 
9663 
  thrift_spec = (
9664 
    None, # 0
9665 
    (1, TType.I64, 'id', None, None, ), # 1
9666 
  )
9667 
 
9668 
  def __init__(self, id=None,):
9669 
    self.id = id
9670 
 
9671 
  def read(self, iprot):
9672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9674 
      return
9675 
    iprot.readStructBegin()
9676 
    while True:
9677 
      (fname, ftype, fid) = iprot.readFieldBegin()
9678 
      if ftype == TType.STOP:
9679 
        break
9680 
      if fid == 1:
9681 
        if ftype == TType.I64:
9682 
          self.id = iprot.readI64();
9683 
        else:
9684 
          iprot.skip(ftype)
9685 
      else:
9686 
        iprot.skip(ftype)
9687 
      iprot.readFieldEnd()
9688 
    iprot.readStructEnd()
9689 
 
9690 
  def write(self, oprot):
9691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9693 
      return
9694 
    oprot.writeStructBegin('getCategory_args')
9695 
    if self.id is not None:
9696 
      oprot.writeFieldBegin('id', TType.I64, 1)
9697 
      oprot.writeI64(self.id)
9698 
      oprot.writeFieldEnd()
9699 
    oprot.writeFieldStop()
9700 
    oprot.writeStructEnd()
9701 
 
9702 
  def validate(self):
9703 
    return
9704 
 
9705 
 
9706 
  def __repr__(self):
9707 
    L = ['%s=%r' % (key, value)
9708 
      for key, value in self.__dict__.iteritems()]
9709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9710 
 
9711 
  def __eq__(self, other):
9712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9713 
 
9714 
  def __ne__(self, other):
9715 
    return not (self == other)
9716 
 
9717 
class getCategory_result:
9718 
  """
9719 
  Attributes:
9720 
   - success
9721 
  """
9722 
 
9723 
  thrift_spec = (
9724 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9725 
  )
9726 
 
9727 
  def __init__(self, success=None,):
9728 
    self.success = success
9729 
 
9730 
  def read(self, iprot):
9731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9733 
      return
9734 
    iprot.readStructBegin()
9735 
    while True:
9736 
      (fname, ftype, fid) = iprot.readFieldBegin()
9737 
      if ftype == TType.STOP:
9738 
        break
9739 
      if fid == 0:
9740 
        if ftype == TType.STRUCT:
9741 
          self.success = Category()
9742 
          self.success.read(iprot)
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      else:
9746 
        iprot.skip(ftype)
9747 
      iprot.readFieldEnd()
9748 
    iprot.readStructEnd()
9749 
 
9750 
  def write(self, oprot):
9751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9753 
      return
9754 
    oprot.writeStructBegin('getCategory_result')
9755 
    if self.success is not None:
9756 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9757 
      self.success.write(oprot)
9758 
      oprot.writeFieldEnd()
9759 
    oprot.writeFieldStop()
9760 
    oprot.writeStructEnd()
9761 
 
9762 
  def validate(self):
9763 
    return
9764 
 
9765 
 
9766 
  def __repr__(self):
9767 
    L = ['%s=%r' % (key, value)
9768 
      for key, value in self.__dict__.iteritems()]
9769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9770 
 
9771 
  def __eq__(self, other):
9772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9773 
 
9774 
  def __ne__(self, other):
9775 
    return not (self == other)
9776 
 
9777 
class getAllCategories_args:
9778 
 
9779 
  thrift_spec = (
9780 
  )
9781 
 
9782 
  def read(self, iprot):
9783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9785 
      return
9786 
    iprot.readStructBegin()
9787 
    while True:
9788 
      (fname, ftype, fid) = iprot.readFieldBegin()
9789 
      if ftype == TType.STOP:
9790 
        break
9791 
      else:
9792 
        iprot.skip(ftype)
9793 
      iprot.readFieldEnd()
9794 
    iprot.readStructEnd()
9795 
 
9796 
  def write(self, oprot):
9797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9799 
      return
9800 
    oprot.writeStructBegin('getAllCategories_args')
9801 
    oprot.writeFieldStop()
9802 
    oprot.writeStructEnd()
9803 
 
9804 
  def validate(self):
9805 
    return
9806 
 
9807 
 
9808 
  def __repr__(self):
9809 
    L = ['%s=%r' % (key, value)
9810 
      for key, value in self.__dict__.iteritems()]
9811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9812 
 
9813 
  def __eq__(self, other):
9814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9815 
 
9816 
  def __ne__(self, other):
9817 
    return not (self == other)
9818 
 
9819 
class getAllCategories_result:
9820 
  """
9821 
  Attributes:
9822 
   - success
9823 
  """
9824 
 
9825 
  thrift_spec = (
9826 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9827 
  )
9828 
 
9829 
  def __init__(self, success=None,):
9830 
    self.success = success
9831 
 
9832 
  def read(self, iprot):
9833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9835 
      return
9836 
    iprot.readStructBegin()
9837 
    while True:
9838 
      (fname, ftype, fid) = iprot.readFieldBegin()
9839 
      if ftype == TType.STOP:
9840 
        break
9841 
      if fid == 0:
9842 
        if ftype == TType.LIST:
9843 
          self.success = []
7438 amit.gupta 9844 
          (_etype140, _size137) = iprot.readListBegin()
9845 
          for _i141 in xrange(_size137):
9846 
            _elem142 = Category()
9847 
            _elem142.read(iprot)
9848 
            self.success.append(_elem142)
5944 mandeep.dh 9849 
          iprot.readListEnd()
9850 
        else:
9851 
          iprot.skip(ftype)
9852 
      else:
9853 
        iprot.skip(ftype)
9854 
      iprot.readFieldEnd()
9855 
    iprot.readStructEnd()
9856 
 
9857 
  def write(self, oprot):
9858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9860 
      return
9861 
    oprot.writeStructBegin('getAllCategories_result')
9862 
    if self.success is not None:
9863 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9864 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9865 
      for iter143 in self.success:
9866 
        iter143.write(oprot)
5944 mandeep.dh 9867 
      oprot.writeListEnd()
9868 
      oprot.writeFieldEnd()
9869 
    oprot.writeFieldStop()
9870 
    oprot.writeStructEnd()
9871 
 
9872 
  def validate(self):
9873 
    return
9874 
 
9875 
 
9876 
  def __repr__(self):
9877 
    L = ['%s=%r' % (key, value)
9878 
      for key, value in self.__dict__.iteritems()]
9879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9880 
 
9881 
  def __eq__(self, other):
9882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9883 
 
9884 
  def __ne__(self, other):
9885 
    return not (self == other)
9886 
 
9887 
class getAllSimilarItems_args:
9888 
  """
9889 
  Attributes:
9890 
   - itemId
9891 
  """
9892 
 
9893 
  thrift_spec = (
9894 
    None, # 0
9895 
    (1, TType.I64, 'itemId', None, None, ), # 1
9896 
  )
9897 
 
9898 
  def __init__(self, itemId=None,):
9899 
    self.itemId = itemId
9900 
 
9901 
  def read(self, iprot):
9902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9904 
      return
9905 
    iprot.readStructBegin()
9906 
    while True:
9907 
      (fname, ftype, fid) = iprot.readFieldBegin()
9908 
      if ftype == TType.STOP:
9909 
        break
9910 
      if fid == 1:
9911 
        if ftype == TType.I64:
9912 
          self.itemId = iprot.readI64();
9913 
        else:
9914 
          iprot.skip(ftype)
9915 
      else:
9916 
        iprot.skip(ftype)
9917 
      iprot.readFieldEnd()
9918 
    iprot.readStructEnd()
9919 
 
9920 
  def write(self, oprot):
9921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9923 
      return
9924 
    oprot.writeStructBegin('getAllSimilarItems_args')
9925 
    if self.itemId is not None:
9926 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9927 
      oprot.writeI64(self.itemId)
9928 
      oprot.writeFieldEnd()
9929 
    oprot.writeFieldStop()
9930 
    oprot.writeStructEnd()
9931 
 
9932 
  def validate(self):
9933 
    return
9934 
 
9935 
 
9936 
  def __repr__(self):
9937 
    L = ['%s=%r' % (key, value)
9938 
      for key, value in self.__dict__.iteritems()]
9939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9940 
 
9941 
  def __eq__(self, other):
9942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9943 
 
9944 
  def __ne__(self, other):
9945 
    return not (self == other)
9946 
 
9947 
class getAllSimilarItems_result:
9948 
  """
9949 
  Attributes:
9950 
   - success
9951 
  """
9952 
 
9953 
  thrift_spec = (
9954 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9955 
  )
9956 
 
9957 
  def __init__(self, success=None,):
9958 
    self.success = success
9959 
 
9960 
  def read(self, iprot):
9961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9963 
      return
9964 
    iprot.readStructBegin()
9965 
    while True:
9966 
      (fname, ftype, fid) = iprot.readFieldBegin()
9967 
      if ftype == TType.STOP:
9968 
        break
9969 
      if fid == 0:
9970 
        if ftype == TType.LIST:
9971 
          self.success = []
7438 amit.gupta 9972 
          (_etype147, _size144) = iprot.readListBegin()
9973 
          for _i148 in xrange(_size144):
9974 
            _elem149 = Item()
9975 
            _elem149.read(iprot)
9976 
            self.success.append(_elem149)
5944 mandeep.dh 9977 
          iprot.readListEnd()
9978 
        else:
9979 
          iprot.skip(ftype)
9980 
      else:
9981 
        iprot.skip(ftype)
9982 
      iprot.readFieldEnd()
9983 
    iprot.readStructEnd()
9984 
 
9985 
  def write(self, oprot):
9986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9988 
      return
9989 
    oprot.writeStructBegin('getAllSimilarItems_result')
9990 
    if self.success is not None:
9991 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9992 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9993 
      for iter150 in self.success:
9994 
        iter150.write(oprot)
5944 mandeep.dh 9995 
      oprot.writeListEnd()
9996 
      oprot.writeFieldEnd()
9997 
    oprot.writeFieldStop()
9998 
    oprot.writeStructEnd()
9999 
 
10000 
  def validate(self):
10001 
    return
10002 
 
10003 
 
10004 
  def __repr__(self):
10005 
    L = ['%s=%r' % (key, value)
10006 
      for key, value in self.__dict__.iteritems()]
10007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10008 
 
10009 
  def __eq__(self, other):
10010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10011 
 
10012 
  def __ne__(self, other):
10013 
    return not (self == other)
10014 
 
10015 
class addSimilarItem_args:
10016 
  """
10017 
  Attributes:
10018 
   - itemId
10019 
   - catalogItemId
10020 
  """
10021 
 
10022 
  thrift_spec = (
10023 
    None, # 0
10024 
    (1, TType.I64, 'itemId', None, None, ), # 1
10025 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10026 
  )
10027 
 
10028 
  def __init__(self, itemId=None, catalogItemId=None,):
10029 
    self.itemId = itemId
10030 
    self.catalogItemId = catalogItemId
10031 
 
10032 
  def read(self, iprot):
10033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10035 
      return
10036 
    iprot.readStructBegin()
10037 
    while True:
10038 
      (fname, ftype, fid) = iprot.readFieldBegin()
10039 
      if ftype == TType.STOP:
10040 
        break
10041 
      if fid == 1:
10042 
        if ftype == TType.I64:
10043 
          self.itemId = iprot.readI64();
10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      elif fid == 2:
10047 
        if ftype == TType.I64:
10048 
          self.catalogItemId = iprot.readI64();
10049 
        else:
10050 
          iprot.skip(ftype)
10051 
      else:
10052 
        iprot.skip(ftype)
10053 
      iprot.readFieldEnd()
10054 
    iprot.readStructEnd()
10055 
 
10056 
  def write(self, oprot):
10057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10059 
      return
10060 
    oprot.writeStructBegin('addSimilarItem_args')
10061 
    if self.itemId is not None:
10062 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10063 
      oprot.writeI64(self.itemId)
10064 
      oprot.writeFieldEnd()
10065 
    if self.catalogItemId is not None:
10066 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10067 
      oprot.writeI64(self.catalogItemId)
10068 
      oprot.writeFieldEnd()
10069 
    oprot.writeFieldStop()
10070 
    oprot.writeStructEnd()
10071 
 
10072 
  def validate(self):
10073 
    return
10074 
 
10075 
 
10076 
  def __repr__(self):
10077 
    L = ['%s=%r' % (key, value)
10078 
      for key, value in self.__dict__.iteritems()]
10079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10080 
 
10081 
  def __eq__(self, other):
10082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10083 
 
10084 
  def __ne__(self, other):
10085 
    return not (self == other)
10086 
 
10087 
class addSimilarItem_result:
10088 
  """
10089 
  Attributes:
10090 
   - success
10091 
   - cex
10092 
  """
10093 
 
10094 
  thrift_spec = (
10095 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10096 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10097 
  )
10098 
 
10099 
  def __init__(self, success=None, cex=None,):
10100 
    self.success = success
10101 
    self.cex = cex
10102 
 
10103 
  def read(self, iprot):
10104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10106 
      return
10107 
    iprot.readStructBegin()
10108 
    while True:
10109 
      (fname, ftype, fid) = iprot.readFieldBegin()
10110 
      if ftype == TType.STOP:
10111 
        break
10112 
      if fid == 0:
10113 
        if ftype == TType.STRUCT:
10114 
          self.success = Item()
10115 
          self.success.read(iprot)
10116 
        else:
10117 
          iprot.skip(ftype)
10118 
      elif fid == 1:
10119 
        if ftype == TType.STRUCT:
10120 
          self.cex = CatalogServiceException()
10121 
          self.cex.read(iprot)
10122 
        else:
10123 
          iprot.skip(ftype)
10124 
      else:
10125 
        iprot.skip(ftype)
10126 
      iprot.readFieldEnd()
10127 
    iprot.readStructEnd()
10128 
 
10129 
  def write(self, oprot):
10130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10132 
      return
10133 
    oprot.writeStructBegin('addSimilarItem_result')
10134 
    if self.success is not None:
10135 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10136 
      self.success.write(oprot)
10137 
      oprot.writeFieldEnd()
10138 
    if self.cex is not None:
10139 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10140 
      self.cex.write(oprot)
10141 
      oprot.writeFieldEnd()
10142 
    oprot.writeFieldStop()
10143 
    oprot.writeStructEnd()
10144 
 
10145 
  def validate(self):
10146 
    return
10147 
 
10148 
 
10149 
  def __repr__(self):
10150 
    L = ['%s=%r' % (key, value)
10151 
      for key, value in self.__dict__.iteritems()]
10152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10153 
 
10154 
  def __eq__(self, other):
10155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10156 
 
10157 
  def __ne__(self, other):
10158 
    return not (self == other)
10159 
 
6512 kshitij.so 10160 
class addTag_args:
10161 
  """
10162 
  Attributes:
10163 
   - displayName
10164 
   - itemId
10165 
  """
10166 
 
10167 
  thrift_spec = (
10168 
    None, # 0
10169 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10170 
    (2, TType.I64, 'itemId', None, None, ), # 2
10171 
  )
10172 
 
10173 
  def __init__(self, displayName=None, itemId=None,):
10174 
    self.displayName = displayName
10175 
    self.itemId = itemId
10176 
 
10177 
  def read(self, iprot):
10178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10180 
      return
10181 
    iprot.readStructBegin()
10182 
    while True:
10183 
      (fname, ftype, fid) = iprot.readFieldBegin()
10184 
      if ftype == TType.STOP:
10185 
        break
10186 
      if fid == 1:
10187 
        if ftype == TType.STRING:
10188 
          self.displayName = iprot.readString();
10189 
        else:
10190 
          iprot.skip(ftype)
10191 
      elif fid == 2:
10192 
        if ftype == TType.I64:
10193 
          self.itemId = iprot.readI64();
10194 
        else:
10195 
          iprot.skip(ftype)
10196 
      else:
10197 
        iprot.skip(ftype)
10198 
      iprot.readFieldEnd()
10199 
    iprot.readStructEnd()
10200 
 
10201 
  def write(self, oprot):
10202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10204 
      return
10205 
    oprot.writeStructBegin('addTag_args')
10206 
    if self.displayName is not None:
10207 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10208 
      oprot.writeString(self.displayName)
10209 
      oprot.writeFieldEnd()
10210 
    if self.itemId is not None:
10211 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10212 
      oprot.writeI64(self.itemId)
10213 
      oprot.writeFieldEnd()
10214 
    oprot.writeFieldStop()
10215 
    oprot.writeStructEnd()
10216 
 
10217 
  def validate(self):
10218 
    return
10219 
 
10220 
 
10221 
  def __repr__(self):
10222 
    L = ['%s=%r' % (key, value)
10223 
      for key, value in self.__dict__.iteritems()]
10224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10225 
 
10226 
  def __eq__(self, other):
10227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10228 
 
10229 
  def __ne__(self, other):
10230 
    return not (self == other)
10231 
 
10232 
class addTag_result:
10233 
  """
10234 
  Attributes:
10235 
   - success
10236 
  """
10237 
 
10238 
  thrift_spec = (
10239 
    (0, TType.BOOL, 'success', None, None, ), # 0
10240 
  )
10241 
 
10242 
  def __init__(self, success=None,):
10243 
    self.success = success
10244 
 
10245 
  def read(self, iprot):
10246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10248 
      return
10249 
    iprot.readStructBegin()
10250 
    while True:
10251 
      (fname, ftype, fid) = iprot.readFieldBegin()
10252 
      if ftype == TType.STOP:
10253 
        break
10254 
      if fid == 0:
10255 
        if ftype == TType.BOOL:
10256 
          self.success = iprot.readBool();
10257 
        else:
10258 
          iprot.skip(ftype)
10259 
      else:
10260 
        iprot.skip(ftype)
10261 
      iprot.readFieldEnd()
10262 
    iprot.readStructEnd()
10263 
 
10264 
  def write(self, oprot):
10265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10267 
      return
10268 
    oprot.writeStructBegin('addTag_result')
10269 
    if self.success is not None:
10270 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10271 
      oprot.writeBool(self.success)
10272 
      oprot.writeFieldEnd()
10273 
    oprot.writeFieldStop()
10274 
    oprot.writeStructEnd()
10275 
 
10276 
  def validate(self):
10277 
    return
10278 
 
10279 
 
10280 
  def __repr__(self):
10281 
    L = ['%s=%r' % (key, value)
10282 
      for key, value in self.__dict__.iteritems()]
10283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10284 
 
10285 
  def __eq__(self, other):
10286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10287 
 
10288 
  def __ne__(self, other):
10289 
    return not (self == other)
10290 
 
10291 
class deleteEntityTag_args:
10292 
  """
10293 
  Attributes:
10294 
   - displayName
10295 
   - itemId
10296 
  """
10297 
 
10298 
  thrift_spec = (
10299 
    None, # 0
10300 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10301 
    (2, TType.I64, 'itemId', None, None, ), # 2
10302 
  )
10303 
 
10304 
  def __init__(self, displayName=None, itemId=None,):
10305 
    self.displayName = displayName
10306 
    self.itemId = itemId
10307 
 
10308 
  def read(self, iprot):
10309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10311 
      return
10312 
    iprot.readStructBegin()
10313 
    while True:
10314 
      (fname, ftype, fid) = iprot.readFieldBegin()
10315 
      if ftype == TType.STOP:
10316 
        break
10317 
      if fid == 1:
10318 
        if ftype == TType.STRING:
10319 
          self.displayName = iprot.readString();
10320 
        else:
10321 
          iprot.skip(ftype)
10322 
      elif fid == 2:
10323 
        if ftype == TType.I64:
10324 
          self.itemId = iprot.readI64();
10325 
        else:
10326 
          iprot.skip(ftype)
10327 
      else:
10328 
        iprot.skip(ftype)
10329 
      iprot.readFieldEnd()
10330 
    iprot.readStructEnd()
10331 
 
10332 
  def write(self, oprot):
10333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10335 
      return
10336 
    oprot.writeStructBegin('deleteEntityTag_args')
10337 
    if self.displayName is not None:
10338 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10339 
      oprot.writeString(self.displayName)
10340 
      oprot.writeFieldEnd()
10341 
    if self.itemId is not None:
10342 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10343 
      oprot.writeI64(self.itemId)
10344 
      oprot.writeFieldEnd()
10345 
    oprot.writeFieldStop()
10346 
    oprot.writeStructEnd()
10347 
 
10348 
  def validate(self):
10349 
    return
10350 
 
10351 
 
10352 
  def __repr__(self):
10353 
    L = ['%s=%r' % (key, value)
10354 
      for key, value in self.__dict__.iteritems()]
10355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10356 
 
10357 
  def __eq__(self, other):
10358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10359 
 
10360 
  def __ne__(self, other):
10361 
    return not (self == other)
10362 
 
10363 
class deleteEntityTag_result:
10364 
  """
10365 
  Attributes:
10366 
   - success
10367 
  """
10368 
 
10369 
  thrift_spec = (
10370 
    (0, TType.BOOL, 'success', None, None, ), # 0
10371 
  )
10372 
 
10373 
  def __init__(self, success=None,):
10374 
    self.success = success
10375 
 
10376 
  def read(self, iprot):
10377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10379 
      return
10380 
    iprot.readStructBegin()
10381 
    while True:
10382 
      (fname, ftype, fid) = iprot.readFieldBegin()
10383 
      if ftype == TType.STOP:
10384 
        break
10385 
      if fid == 0:
10386 
        if ftype == TType.BOOL:
10387 
          self.success = iprot.readBool();
10388 
        else:
10389 
          iprot.skip(ftype)
10390 
      else:
10391 
        iprot.skip(ftype)
10392 
      iprot.readFieldEnd()
10393 
    iprot.readStructEnd()
10394 
 
10395 
  def write(self, oprot):
10396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10398 
      return
10399 
    oprot.writeStructBegin('deleteEntityTag_result')
10400 
    if self.success is not None:
10401 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10402 
      oprot.writeBool(self.success)
10403 
      oprot.writeFieldEnd()
10404 
    oprot.writeFieldStop()
10405 
    oprot.writeStructEnd()
10406 
 
10407 
  def validate(self):
10408 
    return
10409 
 
10410 
 
10411 
  def __repr__(self):
10412 
    L = ['%s=%r' % (key, value)
10413 
      for key, value in self.__dict__.iteritems()]
10414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10415 
 
10416 
  def __eq__(self, other):
10417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10418 
 
10419 
  def __ne__(self, other):
10420 
    return not (self == other)
10421 
 
10422 
class deleteTag_args:
10423 
  """
10424 
  Attributes:
10425 
   - displayName
10426 
  """
10427 
 
10428 
  thrift_spec = (
10429 
    None, # 0
10430 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10431 
  )
10432 
 
10433 
  def __init__(self, displayName=None,):
10434 
    self.displayName = displayName
10435 
 
10436 
  def read(self, iprot):
10437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10439 
      return
10440 
    iprot.readStructBegin()
10441 
    while True:
10442 
      (fname, ftype, fid) = iprot.readFieldBegin()
10443 
      if ftype == TType.STOP:
10444 
        break
10445 
      if fid == 1:
10446 
        if ftype == TType.STRING:
10447 
          self.displayName = iprot.readString();
10448 
        else:
10449 
          iprot.skip(ftype)
10450 
      else:
10451 
        iprot.skip(ftype)
10452 
      iprot.readFieldEnd()
10453 
    iprot.readStructEnd()
10454 
 
10455 
  def write(self, oprot):
10456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10458 
      return
10459 
    oprot.writeStructBegin('deleteTag_args')
10460 
    if self.displayName is not None:
10461 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10462 
      oprot.writeString(self.displayName)
10463 
      oprot.writeFieldEnd()
10464 
    oprot.writeFieldStop()
10465 
    oprot.writeStructEnd()
10466 
 
10467 
  def validate(self):
10468 
    return
10469 
 
10470 
 
10471 
  def __repr__(self):
10472 
    L = ['%s=%r' % (key, value)
10473 
      for key, value in self.__dict__.iteritems()]
10474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10475 
 
10476 
  def __eq__(self, other):
10477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10478 
 
10479 
  def __ne__(self, other):
10480 
    return not (self == other)
10481 
 
10482 
class deleteTag_result:
10483 
  """
10484 
  Attributes:
10485 
   - success
10486 
  """
10487 
 
10488 
  thrift_spec = (
10489 
    (0, TType.BOOL, 'success', None, None, ), # 0
10490 
  )
10491 
 
10492 
  def __init__(self, success=None,):
10493 
    self.success = success
10494 
 
10495 
  def read(self, iprot):
10496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10498 
      return
10499 
    iprot.readStructBegin()
10500 
    while True:
10501 
      (fname, ftype, fid) = iprot.readFieldBegin()
10502 
      if ftype == TType.STOP:
10503 
        break
10504 
      if fid == 0:
10505 
        if ftype == TType.BOOL:
10506 
          self.success = iprot.readBool();
10507 
        else:
10508 
          iprot.skip(ftype)
10509 
      else:
10510 
        iprot.skip(ftype)
10511 
      iprot.readFieldEnd()
10512 
    iprot.readStructEnd()
10513 
 
10514 
  def write(self, oprot):
10515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10517 
      return
10518 
    oprot.writeStructBegin('deleteTag_result')
10519 
    if self.success is not None:
10520 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10521 
      oprot.writeBool(self.success)
10522 
      oprot.writeFieldEnd()
10523 
    oprot.writeFieldStop()
10524 
    oprot.writeStructEnd()
10525 
 
10526 
  def validate(self):
10527 
    return
10528 
 
10529 
 
10530 
  def __repr__(self):
10531 
    L = ['%s=%r' % (key, value)
10532 
      for key, value in self.__dict__.iteritems()]
10533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10534 
 
10535 
  def __eq__(self, other):
10536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10537 
 
10538 
  def __ne__(self, other):
10539 
    return not (self == other)
10540 
 
10541 
class getAllTags_args:
10542 
 
10543 
  thrift_spec = (
10544 
  )
10545 
 
10546 
  def read(self, iprot):
10547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10549 
      return
10550 
    iprot.readStructBegin()
10551 
    while True:
10552 
      (fname, ftype, fid) = iprot.readFieldBegin()
10553 
      if ftype == TType.STOP:
10554 
        break
10555 
      else:
10556 
        iprot.skip(ftype)
10557 
      iprot.readFieldEnd()
10558 
    iprot.readStructEnd()
10559 
 
10560 
  def write(self, oprot):
10561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10563 
      return
10564 
    oprot.writeStructBegin('getAllTags_args')
10565 
    oprot.writeFieldStop()
10566 
    oprot.writeStructEnd()
10567 
 
10568 
  def validate(self):
10569 
    return
10570 
 
10571 
 
10572 
  def __repr__(self):
10573 
    L = ['%s=%r' % (key, value)
10574 
      for key, value in self.__dict__.iteritems()]
10575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10576 
 
10577 
  def __eq__(self, other):
10578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10579 
 
10580 
  def __ne__(self, other):
10581 
    return not (self == other)
10582 
 
10583 
class getAllTags_result:
10584 
  """
10585 
  Attributes:
10586 
   - success
10587 
  """
10588 
 
10589 
  thrift_spec = (
10590 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10591 
  )
10592 
 
10593 
  def __init__(self, success=None,):
10594 
    self.success = success
10595 
 
10596 
  def read(self, iprot):
10597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10599 
      return
10600 
    iprot.readStructBegin()
10601 
    while True:
10602 
      (fname, ftype, fid) = iprot.readFieldBegin()
10603 
      if ftype == TType.STOP:
10604 
        break
10605 
      if fid == 0:
10606 
        if ftype == TType.LIST:
10607 
          self.success = []
7438 amit.gupta 10608 
          (_etype154, _size151) = iprot.readListBegin()
10609 
          for _i155 in xrange(_size151):
10610 
            _elem156 = iprot.readString();
10611 
            self.success.append(_elem156)
6512 kshitij.so 10612 
          iprot.readListEnd()
10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      else:
10616 
        iprot.skip(ftype)
10617 
      iprot.readFieldEnd()
10618 
    iprot.readStructEnd()
10619 
 
10620 
  def write(self, oprot):
10621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10623 
      return
10624 
    oprot.writeStructBegin('getAllTags_result')
10625 
    if self.success is not None:
10626 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10627 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10628 
      for iter157 in self.success:
10629 
        oprot.writeString(iter157)
6512 kshitij.so 10630 
      oprot.writeListEnd()
10631 
      oprot.writeFieldEnd()
10632 
    oprot.writeFieldStop()
10633 
    oprot.writeStructEnd()
10634 
 
10635 
  def validate(self):
10636 
    return
10637 
 
10638 
 
10639 
  def __repr__(self):
10640 
    L = ['%s=%r' % (key, value)
10641 
      for key, value in self.__dict__.iteritems()]
10642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10643 
 
10644 
  def __eq__(self, other):
10645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10646 
 
10647 
  def __ne__(self, other):
10648 
    return not (self == other)
10649 
 
10650 
class getAllEntitiesByTagName_args:
10651 
  """
10652 
  Attributes:
10653 
   - displayName
10654 
  """
10655 
 
10656 
  thrift_spec = (
10657 
    None, # 0
10658 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10659 
  )
10660 
 
10661 
  def __init__(self, displayName=None,):
10662 
    self.displayName = displayName
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      if fid == 1:
10674 
        if ftype == TType.STRING:
10675 
          self.displayName = iprot.readString();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      else:
10679 
        iprot.skip(ftype)
10680 
      iprot.readFieldEnd()
10681 
    iprot.readStructEnd()
10682 
 
10683 
  def write(self, oprot):
10684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10686 
      return
10687 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10688 
    if self.displayName is not None:
10689 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10690 
      oprot.writeString(self.displayName)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
10710 
class getAllEntitiesByTagName_result:
10711 
  """
10712 
  Attributes:
10713 
   - success
10714 
  """
10715 
 
10716 
  thrift_spec = (
10717 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10718 
  )
10719 
 
10720 
  def __init__(self, success=None,):
10721 
    self.success = success
10722 
 
10723 
  def read(self, iprot):
10724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10726 
      return
10727 
    iprot.readStructBegin()
10728 
    while True:
10729 
      (fname, ftype, fid) = iprot.readFieldBegin()
10730 
      if ftype == TType.STOP:
10731 
        break
10732 
      if fid == 0:
10733 
        if ftype == TType.LIST:
10734 
          self.success = []
7438 amit.gupta 10735 
          (_etype161, _size158) = iprot.readListBegin()
10736 
          for _i162 in xrange(_size158):
10737 
            _elem163 = iprot.readI64();
10738 
            self.success.append(_elem163)
6512 kshitij.so 10739 
          iprot.readListEnd()
10740 
        else:
10741 
          iprot.skip(ftype)
10742 
      else:
10743 
        iprot.skip(ftype)
10744 
      iprot.readFieldEnd()
10745 
    iprot.readStructEnd()
10746 
 
10747 
  def write(self, oprot):
10748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10750 
      return
10751 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10752 
    if self.success is not None:
10753 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10754 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10755 
      for iter164 in self.success:
10756 
        oprot.writeI64(iter164)
6512 kshitij.so 10757 
      oprot.writeListEnd()
10758 
      oprot.writeFieldEnd()
10759 
    oprot.writeFieldStop()
10760 
    oprot.writeStructEnd()
10761 
 
10762 
  def validate(self):
10763 
    return
10764 
 
10765 
 
10766 
  def __repr__(self):
10767 
    L = ['%s=%r' % (key, value)
10768 
      for key, value in self.__dict__.iteritems()]
10769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10770 
 
10771 
  def __eq__(self, other):
10772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10773 
 
10774 
  def __ne__(self, other):
10775 
    return not (self == other)
10776 
 
6845 amit.gupta 10777 
class getAllEntityTags_args:
10778 
 
10779 
  thrift_spec = (
10780 
  )
10781 
 
10782 
  def read(self, iprot):
10783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10785 
      return
10786 
    iprot.readStructBegin()
10787 
    while True:
10788 
      (fname, ftype, fid) = iprot.readFieldBegin()
10789 
      if ftype == TType.STOP:
10790 
        break
10791 
      else:
10792 
        iprot.skip(ftype)
10793 
      iprot.readFieldEnd()
10794 
    iprot.readStructEnd()
10795 
 
10796 
  def write(self, oprot):
10797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10799 
      return
10800 
    oprot.writeStructBegin('getAllEntityTags_args')
10801 
    oprot.writeFieldStop()
10802 
    oprot.writeStructEnd()
10803 
 
10804 
  def validate(self):
10805 
    return
10806 
 
10807 
 
10808 
  def __repr__(self):
10809 
    L = ['%s=%r' % (key, value)
10810 
      for key, value in self.__dict__.iteritems()]
10811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10812 
 
10813 
  def __eq__(self, other):
10814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10815 
 
10816 
  def __ne__(self, other):
10817 
    return not (self == other)
10818 
 
10819 
class getAllEntityTags_result:
10820 
  """
10821 
  Attributes:
10822 
   - success
10823 
  """
10824 
 
10825 
  thrift_spec = (
10826 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10827 
  )
10828 
 
10829 
  def __init__(self, success=None,):
10830 
    self.success = success
10831 
 
10832 
  def read(self, iprot):
10833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10835 
      return
10836 
    iprot.readStructBegin()
10837 
    while True:
10838 
      (fname, ftype, fid) = iprot.readFieldBegin()
10839 
      if ftype == TType.STOP:
10840 
        break
10841 
      if fid == 0:
10842 
        if ftype == TType.MAP:
10843 
          self.success = {}
7438 amit.gupta 10844 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10845 
          for _i169 in xrange(_size165):
10846 
            _key170 = iprot.readI64();
10847 
            _val171 = []
10848 
            (_etype175, _size172) = iprot.readListBegin()
10849 
            for _i176 in xrange(_size172):
10850 
              _elem177 = iprot.readString();
10851 
              _val171.append(_elem177)
6845 amit.gupta 10852 
            iprot.readListEnd()
7438 amit.gupta 10853 
            self.success[_key170] = _val171
6845 amit.gupta 10854 
          iprot.readMapEnd()
10855 
        else:
10856 
          iprot.skip(ftype)
10857 
      else:
10858 
        iprot.skip(ftype)
10859 
      iprot.readFieldEnd()
10860 
    iprot.readStructEnd()
10861 
 
10862 
  def write(self, oprot):
10863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10865 
      return
10866 
    oprot.writeStructBegin('getAllEntityTags_result')
10867 
    if self.success is not None:
10868 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10869 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10870 
      for kiter178,viter179 in self.success.items():
10871 
        oprot.writeI64(kiter178)
10872 
        oprot.writeListBegin(TType.STRING, len(viter179))
10873 
        for iter180 in viter179:
10874 
          oprot.writeString(iter180)
6845 amit.gupta 10875 
        oprot.writeListEnd()
10876 
      oprot.writeMapEnd()
10877 
      oprot.writeFieldEnd()
10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
6850 kshitij.so 10896 
class addBanner_args:
10897 
  """
10898 
  Attributes:
10899 
   - bannerName
10900 
   - imageName
10901 
   - link
10902 
   - priority
10903 
   - isActive
10904 
   - hasMap
10905 
  """
10906 
 
10907 
  thrift_spec = (
10908 
    None, # 0
10909 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10910 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10911 
    (3, TType.STRING, 'link', None, None, ), # 3
10912 
    (4, TType.I64, 'priority', None, None, ), # 4
10913 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10914 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10915 
  )
10916 
 
10917 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10918 
    self.bannerName = bannerName
10919 
    self.imageName = imageName
10920 
    self.link = link
10921 
    self.priority = priority
10922 
    self.isActive = isActive
10923 
    self.hasMap = hasMap
10924 
 
10925 
  def read(self, iprot):
10926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10928 
      return
10929 
    iprot.readStructBegin()
10930 
    while True:
10931 
      (fname, ftype, fid) = iprot.readFieldBegin()
10932 
      if ftype == TType.STOP:
10933 
        break
10934 
      if fid == 1:
10935 
        if ftype == TType.STRING:
10936 
          self.bannerName = iprot.readString();
10937 
        else:
10938 
          iprot.skip(ftype)
10939 
      elif fid == 2:
10940 
        if ftype == TType.STRING:
10941 
          self.imageName = iprot.readString();
10942 
        else:
10943 
          iprot.skip(ftype)
10944 
      elif fid == 3:
10945 
        if ftype == TType.STRING:
10946 
          self.link = iprot.readString();
10947 
        else:
10948 
          iprot.skip(ftype)
10949 
      elif fid == 4:
10950 
        if ftype == TType.I64:
10951 
          self.priority = iprot.readI64();
10952 
        else:
10953 
          iprot.skip(ftype)
10954 
      elif fid == 5:
10955 
        if ftype == TType.BOOL:
10956 
          self.isActive = iprot.readBool();
10957 
        else:
10958 
          iprot.skip(ftype)
10959 
      elif fid == 6:
10960 
        if ftype == TType.BOOL:
10961 
          self.hasMap = iprot.readBool();
10962 
        else:
10963 
          iprot.skip(ftype)
10964 
      else:
10965 
        iprot.skip(ftype)
10966 
      iprot.readFieldEnd()
10967 
    iprot.readStructEnd()
10968 
 
10969 
  def write(self, oprot):
10970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10972 
      return
10973 
    oprot.writeStructBegin('addBanner_args')
10974 
    if self.bannerName is not None:
10975 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10976 
      oprot.writeString(self.bannerName)
10977 
      oprot.writeFieldEnd()
10978 
    if self.imageName is not None:
10979 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10980 
      oprot.writeString(self.imageName)
10981 
      oprot.writeFieldEnd()
10982 
    if self.link is not None:
10983 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10984 
      oprot.writeString(self.link)
10985 
      oprot.writeFieldEnd()
10986 
    if self.priority is not None:
10987 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10988 
      oprot.writeI64(self.priority)
10989 
      oprot.writeFieldEnd()
10990 
    if self.isActive is not None:
10991 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10992 
      oprot.writeBool(self.isActive)
10993 
      oprot.writeFieldEnd()
10994 
    if self.hasMap is not None:
10995 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10996 
      oprot.writeBool(self.hasMap)
10997 
      oprot.writeFieldEnd()
10998 
    oprot.writeFieldStop()
10999 
    oprot.writeStructEnd()
11000 
 
11001 
  def validate(self):
11002 
    return
11003 
 
11004 
 
11005 
  def __repr__(self):
11006 
    L = ['%s=%r' % (key, value)
11007 
      for key, value in self.__dict__.iteritems()]
11008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11009 
 
11010 
  def __eq__(self, other):
11011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11012 
 
11013 
  def __ne__(self, other):
11014 
    return not (self == other)
11015 
 
11016 
class addBanner_result:
11017 
  """
11018 
  Attributes:
11019 
   - success
11020 
  """
11021 
 
11022 
  thrift_spec = (
11023 
    (0, TType.BOOL, 'success', None, None, ), # 0
11024 
  )
11025 
 
11026 
  def __init__(self, success=None,):
11027 
    self.success = success
11028 
 
11029 
  def read(self, iprot):
11030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11032 
      return
11033 
    iprot.readStructBegin()
11034 
    while True:
11035 
      (fname, ftype, fid) = iprot.readFieldBegin()
11036 
      if ftype == TType.STOP:
11037 
        break
11038 
      if fid == 0:
11039 
        if ftype == TType.BOOL:
11040 
          self.success = iprot.readBool();
11041 
        else:
11042 
          iprot.skip(ftype)
11043 
      else:
11044 
        iprot.skip(ftype)
11045 
      iprot.readFieldEnd()
11046 
    iprot.readStructEnd()
11047 
 
11048 
  def write(self, oprot):
11049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11051 
      return
11052 
    oprot.writeStructBegin('addBanner_result')
11053 
    if self.success is not None:
11054 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11055 
      oprot.writeBool(self.success)
11056 
      oprot.writeFieldEnd()
11057 
    oprot.writeFieldStop()
11058 
    oprot.writeStructEnd()
11059 
 
11060 
  def validate(self):
11061 
    return
11062 
 
11063 
 
11064 
  def __repr__(self):
11065 
    L = ['%s=%r' % (key, value)
11066 
      for key, value in self.__dict__.iteritems()]
11067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11068 
 
11069 
  def __eq__(self, other):
11070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11071 
 
11072 
  def __ne__(self, other):
11073 
    return not (self == other)
11074 
 
11075 
class getAllBanners_args:
11076 
 
11077 
  thrift_spec = (
11078 
  )
11079 
 
11080 
  def read(self, iprot):
11081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11083 
      return
11084 
    iprot.readStructBegin()
11085 
    while True:
11086 
      (fname, ftype, fid) = iprot.readFieldBegin()
11087 
      if ftype == TType.STOP:
11088 
        break
11089 
      else:
11090 
        iprot.skip(ftype)
11091 
      iprot.readFieldEnd()
11092 
    iprot.readStructEnd()
11093 
 
11094 
  def write(self, oprot):
11095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11097 
      return
11098 
    oprot.writeStructBegin('getAllBanners_args')
11099 
    oprot.writeFieldStop()
11100 
    oprot.writeStructEnd()
11101 
 
11102 
  def validate(self):
11103 
    return
11104 
 
11105 
 
11106 
  def __repr__(self):
11107 
    L = ['%s=%r' % (key, value)
11108 
      for key, value in self.__dict__.iteritems()]
11109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11110 
 
11111 
  def __eq__(self, other):
11112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11113 
 
11114 
  def __ne__(self, other):
11115 
    return not (self == other)
11116 
 
11117 
class getAllBanners_result:
11118 
  """
11119 
  Attributes:
11120 
   - success
11121 
  """
11122 
 
11123 
  thrift_spec = (
11124 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11125 
  )
11126 
 
11127 
  def __init__(self, success=None,):
11128 
    self.success = success
11129 
 
11130 
  def read(self, iprot):
11131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11133 
      return
11134 
    iprot.readStructBegin()
11135 
    while True:
11136 
      (fname, ftype, fid) = iprot.readFieldBegin()
11137 
      if ftype == TType.STOP:
11138 
        break
11139 
      if fid == 0:
11140 
        if ftype == TType.LIST:
11141 
          self.success = []
7438 amit.gupta 11142 
          (_etype184, _size181) = iprot.readListBegin()
11143 
          for _i185 in xrange(_size181):
11144 
            _elem186 = iprot.readString();
11145 
            self.success.append(_elem186)
6850 kshitij.so 11146 
          iprot.readListEnd()
11147 
        else:
11148 
          iprot.skip(ftype)
11149 
      else:
11150 
        iprot.skip(ftype)
11151 
      iprot.readFieldEnd()
11152 
    iprot.readStructEnd()
11153 
 
11154 
  def write(self, oprot):
11155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11157 
      return
11158 
    oprot.writeStructBegin('getAllBanners_result')
11159 
    if self.success is not None:
11160 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11161 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11162 
      for iter187 in self.success:
11163 
        oprot.writeString(iter187)
6850 kshitij.so 11164 
      oprot.writeListEnd()
11165 
      oprot.writeFieldEnd()
11166 
    oprot.writeFieldStop()
11167 
    oprot.writeStructEnd()
11168 
 
11169 
  def validate(self):
11170 
    return
11171 
 
11172 
 
11173 
  def __repr__(self):
11174 
    L = ['%s=%r' % (key, value)
11175 
      for key, value in self.__dict__.iteritems()]
11176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11177 
 
11178 
  def __eq__(self, other):
11179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11180 
 
11181 
  def __ne__(self, other):
11182 
    return not (self == other)
11183 
 
11184 
class deleteBanner_args:
11185 
  """
11186 
  Attributes:
11187 
   - bannerName
11188 
  """
11189 
 
11190 
  thrift_spec = (
11191 
    None, # 0
11192 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11193 
  )
11194 
 
11195 
  def __init__(self, bannerName=None,):
11196 
    self.bannerName = bannerName
11197 
 
11198 
  def read(self, iprot):
11199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11201 
      return
11202 
    iprot.readStructBegin()
11203 
    while True:
11204 
      (fname, ftype, fid) = iprot.readFieldBegin()
11205 
      if ftype == TType.STOP:
11206 
        break
11207 
      if fid == 1:
11208 
        if ftype == TType.STRING:
11209 
          self.bannerName = iprot.readString();
11210 
        else:
11211 
          iprot.skip(ftype)
11212 
      else:
11213 
        iprot.skip(ftype)
11214 
      iprot.readFieldEnd()
11215 
    iprot.readStructEnd()
11216 
 
11217 
  def write(self, oprot):
11218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11220 
      return
11221 
    oprot.writeStructBegin('deleteBanner_args')
11222 
    if self.bannerName is not None:
11223 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11224 
      oprot.writeString(self.bannerName)
11225 
      oprot.writeFieldEnd()
11226 
    oprot.writeFieldStop()
11227 
    oprot.writeStructEnd()
11228 
 
11229 
  def validate(self):
11230 
    return
11231 
 
11232 
 
11233 
  def __repr__(self):
11234 
    L = ['%s=%r' % (key, value)
11235 
      for key, value in self.__dict__.iteritems()]
11236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11237 
 
11238 
  def __eq__(self, other):
11239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11240 
 
11241 
  def __ne__(self, other):
11242 
    return not (self == other)
11243 
 
11244 
class deleteBanner_result:
11245 
  """
11246 
  Attributes:
11247 
   - success
11248 
  """
11249 
 
11250 
  thrift_spec = (
11251 
    (0, TType.BOOL, 'success', None, None, ), # 0
11252 
  )
11253 
 
11254 
  def __init__(self, success=None,):
11255 
    self.success = success
11256 
 
11257 
  def read(self, iprot):
11258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11260 
      return
11261 
    iprot.readStructBegin()
11262 
    while True:
11263 
      (fname, ftype, fid) = iprot.readFieldBegin()
11264 
      if ftype == TType.STOP:
11265 
        break
11266 
      if fid == 0:
11267 
        if ftype == TType.BOOL:
11268 
          self.success = iprot.readBool();
11269 
        else:
11270 
          iprot.skip(ftype)
11271 
      else:
11272 
        iprot.skip(ftype)
11273 
      iprot.readFieldEnd()
11274 
    iprot.readStructEnd()
11275 
 
11276 
  def write(self, oprot):
11277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11279 
      return
11280 
    oprot.writeStructBegin('deleteBanner_result')
11281 
    if self.success is not None:
11282 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11283 
      oprot.writeBool(self.success)
11284 
      oprot.writeFieldEnd()
11285 
    oprot.writeFieldStop()
11286 
    oprot.writeStructEnd()
11287 
 
11288 
  def validate(self):
11289 
    return
11290 
 
11291 
 
11292 
  def __repr__(self):
11293 
    L = ['%s=%r' % (key, value)
11294 
      for key, value in self.__dict__.iteritems()]
11295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11296 
 
11297 
  def __eq__(self, other):
11298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11299 
 
11300 
  def __ne__(self, other):
11301 
    return not (self == other)
11302 
 
11303 
class getBannerDetails_args:
11304 
  """
11305 
  Attributes:
11306 
   - bannerName
11307 
  """
11308 
 
11309 
  thrift_spec = (
11310 
    None, # 0
11311 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11312 
  )
11313 
 
11314 
  def __init__(self, bannerName=None,):
11315 
    self.bannerName = bannerName
11316 
 
11317 
  def read(self, iprot):
11318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11320 
      return
11321 
    iprot.readStructBegin()
11322 
    while True:
11323 
      (fname, ftype, fid) = iprot.readFieldBegin()
11324 
      if ftype == TType.STOP:
11325 
        break
11326 
      if fid == 1:
11327 
        if ftype == TType.STRING:
11328 
          self.bannerName = iprot.readString();
11329 
        else:
11330 
          iprot.skip(ftype)
11331 
      else:
11332 
        iprot.skip(ftype)
11333 
      iprot.readFieldEnd()
11334 
    iprot.readStructEnd()
11335 
 
11336 
  def write(self, oprot):
11337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11339 
      return
11340 
    oprot.writeStructBegin('getBannerDetails_args')
11341 
    if self.bannerName is not None:
11342 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11343 
      oprot.writeString(self.bannerName)
11344 
      oprot.writeFieldEnd()
11345 
    oprot.writeFieldStop()
11346 
    oprot.writeStructEnd()
11347 
 
11348 
  def validate(self):
11349 
    return
11350 
 
11351 
 
11352 
  def __repr__(self):
11353 
    L = ['%s=%r' % (key, value)
11354 
      for key, value in self.__dict__.iteritems()]
11355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11356 
 
11357 
  def __eq__(self, other):
11358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11359 
 
11360 
  def __ne__(self, other):
11361 
    return not (self == other)
11362 
 
11363 
class getBannerDetails_result:
11364 
  """
11365 
  Attributes:
11366 
   - success
11367 
  """
11368 
 
11369 
  thrift_spec = (
11370 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11371 
  )
11372 
 
11373 
  def __init__(self, success=None,):
11374 
    self.success = success
11375 
 
11376 
  def read(self, iprot):
11377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11379 
      return
11380 
    iprot.readStructBegin()
11381 
    while True:
11382 
      (fname, ftype, fid) = iprot.readFieldBegin()
11383 
      if ftype == TType.STOP:
11384 
        break
11385 
      if fid == 0:
11386 
        if ftype == TType.STRUCT:
11387 
          self.success = Banner()
11388 
          self.success.read(iprot)
11389 
        else:
11390 
          iprot.skip(ftype)
11391 
      else:
11392 
        iprot.skip(ftype)
11393 
      iprot.readFieldEnd()
11394 
    iprot.readStructEnd()
11395 
 
11396 
  def write(self, oprot):
11397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11399 
      return
11400 
    oprot.writeStructBegin('getBannerDetails_result')
11401 
    if self.success is not None:
11402 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11403 
      self.success.write(oprot)
11404 
      oprot.writeFieldEnd()
11405 
    oprot.writeFieldStop()
11406 
    oprot.writeStructEnd()
11407 
 
11408 
  def validate(self):
11409 
    return
11410 
 
11411 
 
11412 
  def __repr__(self):
11413 
    L = ['%s=%r' % (key, value)
11414 
      for key, value in self.__dict__.iteritems()]
11415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11416 
 
11417 
  def __eq__(self, other):
11418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11419 
 
11420 
  def __ne__(self, other):
11421 
    return not (self == other)
11422 
 
11423 
class getActiveBanners_args:
11424 
 
11425 
  thrift_spec = (
11426 
  )
11427 
 
11428 
  def read(self, iprot):
11429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11431 
      return
11432 
    iprot.readStructBegin()
11433 
    while True:
11434 
      (fname, ftype, fid) = iprot.readFieldBegin()
11435 
      if ftype == TType.STOP:
11436 
        break
11437 
      else:
11438 
        iprot.skip(ftype)
11439 
      iprot.readFieldEnd()
11440 
    iprot.readStructEnd()
11441 
 
11442 
  def write(self, oprot):
11443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11445 
      return
11446 
    oprot.writeStructBegin('getActiveBanners_args')
11447 
    oprot.writeFieldStop()
11448 
    oprot.writeStructEnd()
11449 
 
11450 
  def validate(self):
11451 
    return
11452 
 
11453 
 
11454 
  def __repr__(self):
11455 
    L = ['%s=%r' % (key, value)
11456 
      for key, value in self.__dict__.iteritems()]
11457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11458 
 
11459 
  def __eq__(self, other):
11460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11461 
 
11462 
  def __ne__(self, other):
11463 
    return not (self == other)
11464 
 
11465 
class getActiveBanners_result:
11466 
  """
11467 
  Attributes:
11468 
   - success
11469 
  """
11470 
 
11471 
  thrift_spec = (
11472 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11473 
  )
11474 
 
11475 
  def __init__(self, success=None,):
11476 
    self.success = success
11477 
 
11478 
  def read(self, iprot):
11479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11481 
      return
11482 
    iprot.readStructBegin()
11483 
    while True:
11484 
      (fname, ftype, fid) = iprot.readFieldBegin()
11485 
      if ftype == TType.STOP:
11486 
        break
11487 
      if fid == 0:
11488 
        if ftype == TType.LIST:
11489 
          self.success = []
7438 amit.gupta 11490 
          (_etype191, _size188) = iprot.readListBegin()
11491 
          for _i192 in xrange(_size188):
11492 
            _elem193 = Banner()
11493 
            _elem193.read(iprot)
11494 
            self.success.append(_elem193)
6850 kshitij.so 11495 
          iprot.readListEnd()
11496 
        else:
11497 
          iprot.skip(ftype)
11498 
      else:
11499 
        iprot.skip(ftype)
11500 
      iprot.readFieldEnd()
11501 
    iprot.readStructEnd()
11502 
 
11503 
  def write(self, oprot):
11504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11506 
      return
11507 
    oprot.writeStructBegin('getActiveBanners_result')
11508 
    if self.success is not None:
11509 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11510 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11511 
      for iter194 in self.success:
11512 
        iter194.write(oprot)
6850 kshitij.so 11513 
      oprot.writeListEnd()
11514 
      oprot.writeFieldEnd()
11515 
    oprot.writeFieldStop()
11516 
    oprot.writeStructEnd()
11517 
 
11518 
  def validate(self):
11519 
    return
11520 
 
11521 
 
11522 
  def __repr__(self):
11523 
    L = ['%s=%r' % (key, value)
11524 
      for key, value in self.__dict__.iteritems()]
11525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11526 
 
11527 
  def __eq__(self, other):
11528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11529 
 
11530 
  def __ne__(self, other):
11531 
    return not (self == other)
11532 
 
6849 kshitij.so 11533 
class addBannerMap_args:
11534 
  """
11535 
  Attributes:
11536 
   - bannerName
11537 
   - mapLink
11538 
   - coordinates
11539 
  """
11540 
 
11541 
  thrift_spec = (
11542 
    None, # 0
11543 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11544 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11545 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11546 
  )
11547 
 
11548 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11549 
    self.bannerName = bannerName
11550 
    self.mapLink = mapLink
11551 
    self.coordinates = coordinates
11552 
 
11553 
  def read(self, iprot):
11554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11556 
      return
11557 
    iprot.readStructBegin()
11558 
    while True:
11559 
      (fname, ftype, fid) = iprot.readFieldBegin()
11560 
      if ftype == TType.STOP:
11561 
        break
11562 
      if fid == 1:
11563 
        if ftype == TType.STRING:
11564 
          self.bannerName = iprot.readString();
11565 
        else:
11566 
          iprot.skip(ftype)
11567 
      elif fid == 2:
11568 
        if ftype == TType.STRING:
11569 
          self.mapLink = iprot.readString();
11570 
        else:
11571 
          iprot.skip(ftype)
11572 
      elif fid == 3:
11573 
        if ftype == TType.STRING:
11574 
          self.coordinates = iprot.readString();
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      else:
11578 
        iprot.skip(ftype)
11579 
      iprot.readFieldEnd()
11580 
    iprot.readStructEnd()
11581 
 
11582 
  def write(self, oprot):
11583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11585 
      return
11586 
    oprot.writeStructBegin('addBannerMap_args')
11587 
    if self.bannerName is not None:
11588 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11589 
      oprot.writeString(self.bannerName)
11590 
      oprot.writeFieldEnd()
11591 
    if self.mapLink is not None:
11592 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11593 
      oprot.writeString(self.mapLink)
11594 
      oprot.writeFieldEnd()
11595 
    if self.coordinates is not None:
11596 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11597 
      oprot.writeString(self.coordinates)
11598 
      oprot.writeFieldEnd()
11599 
    oprot.writeFieldStop()
11600 
    oprot.writeStructEnd()
11601 
 
11602 
  def validate(self):
11603 
    return
11604 
 
11605 
 
11606 
  def __repr__(self):
11607 
    L = ['%s=%r' % (key, value)
11608 
      for key, value in self.__dict__.iteritems()]
11609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11610 
 
11611 
  def __eq__(self, other):
11612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11613 
 
11614 
  def __ne__(self, other):
11615 
    return not (self == other)
11616 
 
11617 
class addBannerMap_result:
11618 
  """
11619 
  Attributes:
11620 
   - success
11621 
  """
11622 
 
11623 
  thrift_spec = (
11624 
    (0, TType.BOOL, 'success', None, None, ), # 0
11625 
  )
11626 
 
11627 
  def __init__(self, success=None,):
11628 
    self.success = success
11629 
 
11630 
  def read(self, iprot):
11631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11633 
      return
11634 
    iprot.readStructBegin()
11635 
    while True:
11636 
      (fname, ftype, fid) = iprot.readFieldBegin()
11637 
      if ftype == TType.STOP:
11638 
        break
11639 
      if fid == 0:
11640 
        if ftype == TType.BOOL:
11641 
          self.success = iprot.readBool();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('addBannerMap_result')
11654 
    if self.success is not None:
11655 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11656 
      oprot.writeBool(self.success)
11657 
      oprot.writeFieldEnd()
11658 
    oprot.writeFieldStop()
11659 
    oprot.writeStructEnd()
11660 
 
11661 
  def validate(self):
11662 
    return
11663 
 
11664 
 
11665 
  def __repr__(self):
11666 
    L = ['%s=%r' % (key, value)
11667 
      for key, value in self.__dict__.iteritems()]
11668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11669 
 
11670 
  def __eq__(self, other):
11671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11672 
 
11673 
  def __ne__(self, other):
11674 
    return not (self == other)
11675 
 
11676 
class deleteBannerMap_args:
11677 
  """
11678 
  Attributes:
11679 
   - bannerName
11680 
  """
11681 
 
11682 
  thrift_spec = (
11683 
    None, # 0
11684 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11685 
  )
11686 
 
11687 
  def __init__(self, bannerName=None,):
11688 
    self.bannerName = bannerName
11689 
 
11690 
  def read(self, iprot):
11691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11693 
      return
11694 
    iprot.readStructBegin()
11695 
    while True:
11696 
      (fname, ftype, fid) = iprot.readFieldBegin()
11697 
      if ftype == TType.STOP:
11698 
        break
11699 
      if fid == 1:
11700 
        if ftype == TType.STRING:
11701 
          self.bannerName = iprot.readString();
11702 
        else:
11703 
          iprot.skip(ftype)
11704 
      else:
11705 
        iprot.skip(ftype)
11706 
      iprot.readFieldEnd()
11707 
    iprot.readStructEnd()
11708 
 
11709 
  def write(self, oprot):
11710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11712 
      return
11713 
    oprot.writeStructBegin('deleteBannerMap_args')
11714 
    if self.bannerName is not None:
11715 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11716 
      oprot.writeString(self.bannerName)
11717 
      oprot.writeFieldEnd()
11718 
    oprot.writeFieldStop()
11719 
    oprot.writeStructEnd()
11720 
 
11721 
  def validate(self):
11722 
    return
11723 
 
11724 
 
11725 
  def __repr__(self):
11726 
    L = ['%s=%r' % (key, value)
11727 
      for key, value in self.__dict__.iteritems()]
11728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11729 
 
11730 
  def __eq__(self, other):
11731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11732 
 
11733 
  def __ne__(self, other):
11734 
    return not (self == other)
11735 
 
11736 
class deleteBannerMap_result:
11737 
  """
11738 
  Attributes:
11739 
   - success
11740 
  """
11741 
 
11742 
  thrift_spec = (
11743 
    (0, TType.BOOL, 'success', None, None, ), # 0
11744 
  )
11745 
 
11746 
  def __init__(self, success=None,):
11747 
    self.success = success
11748 
 
11749 
  def read(self, iprot):
11750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11752 
      return
11753 
    iprot.readStructBegin()
11754 
    while True:
11755 
      (fname, ftype, fid) = iprot.readFieldBegin()
11756 
      if ftype == TType.STOP:
11757 
        break
11758 
      if fid == 0:
11759 
        if ftype == TType.BOOL:
11760 
          self.success = iprot.readBool();
11761 
        else:
11762 
          iprot.skip(ftype)
11763 
      else:
11764 
        iprot.skip(ftype)
11765 
      iprot.readFieldEnd()
11766 
    iprot.readStructEnd()
11767 
 
11768 
  def write(self, oprot):
11769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11771 
      return
11772 
    oprot.writeStructBegin('deleteBannerMap_result')
11773 
    if self.success is not None:
11774 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11775 
      oprot.writeBool(self.success)
11776 
      oprot.writeFieldEnd()
11777 
    oprot.writeFieldStop()
11778 
    oprot.writeStructEnd()
11779 
 
11780 
  def validate(self):
11781 
    return
11782 
 
11783 
 
11784 
  def __repr__(self):
11785 
    L = ['%s=%r' % (key, value)
11786 
      for key, value in self.__dict__.iteritems()]
11787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11788 
 
11789 
  def __eq__(self, other):
11790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11791 
 
11792 
  def __ne__(self, other):
11793 
    return not (self == other)
11794 
 
11795 
class getBannerMapDetails_args:
11796 
  """
11797 
  Attributes:
11798 
   - bannerName
11799 
  """
11800 
 
11801 
  thrift_spec = (
11802 
    None, # 0
11803 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11804 
  )
11805 
 
11806 
  def __init__(self, bannerName=None,):
11807 
    self.bannerName = bannerName
11808 
 
11809 
  def read(self, iprot):
11810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11812 
      return
11813 
    iprot.readStructBegin()
11814 
    while True:
11815 
      (fname, ftype, fid) = iprot.readFieldBegin()
11816 
      if ftype == TType.STOP:
11817 
        break
11818 
      if fid == 1:
11819 
        if ftype == TType.STRING:
11820 
          self.bannerName = iprot.readString();
11821 
        else:
11822 
          iprot.skip(ftype)
11823 
      else:
11824 
        iprot.skip(ftype)
11825 
      iprot.readFieldEnd()
11826 
    iprot.readStructEnd()
11827 
 
11828 
  def write(self, oprot):
11829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11831 
      return
11832 
    oprot.writeStructBegin('getBannerMapDetails_args')
11833 
    if self.bannerName is not None:
11834 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11835 
      oprot.writeString(self.bannerName)
11836 
      oprot.writeFieldEnd()
11837 
    oprot.writeFieldStop()
11838 
    oprot.writeStructEnd()
11839 
 
11840 
  def validate(self):
11841 
    return
11842 
 
11843 
 
11844 
  def __repr__(self):
11845 
    L = ['%s=%r' % (key, value)
11846 
      for key, value in self.__dict__.iteritems()]
11847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11848 
 
11849 
  def __eq__(self, other):
11850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11851 
 
11852 
  def __ne__(self, other):
11853 
    return not (self == other)
11854 
 
11855 
class getBannerMapDetails_result:
11856 
  """
11857 
  Attributes:
11858 
   - success
11859 
  """
11860 
 
11861 
  thrift_spec = (
11862 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11863 
  )
11864 
 
11865 
  def __init__(self, success=None,):
11866 
    self.success = success
11867 
 
11868 
  def read(self, iprot):
11869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11871 
      return
11872 
    iprot.readStructBegin()
11873 
    while True:
11874 
      (fname, ftype, fid) = iprot.readFieldBegin()
11875 
      if ftype == TType.STOP:
11876 
        break
11877 
      if fid == 0:
11878 
        if ftype == TType.LIST:
11879 
          self.success = []
7438 amit.gupta 11880 
          (_etype198, _size195) = iprot.readListBegin()
11881 
          for _i199 in xrange(_size195):
11882 
            _elem200 = BannerMap()
11883 
            _elem200.read(iprot)
11884 
            self.success.append(_elem200)
6849 kshitij.so 11885 
          iprot.readListEnd()
11886 
        else:
11887 
          iprot.skip(ftype)
11888 
      else:
11889 
        iprot.skip(ftype)
11890 
      iprot.readFieldEnd()
11891 
    iprot.readStructEnd()
11892 
 
11893 
  def write(self, oprot):
11894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11896 
      return
11897 
    oprot.writeStructBegin('getBannerMapDetails_result')
11898 
    if self.success is not None:
11899 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11900 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11901 
      for iter201 in self.success:
11902 
        iter201.write(oprot)
6849 kshitij.so 11903 
      oprot.writeListEnd()
11904 
      oprot.writeFieldEnd()
11905 
    oprot.writeFieldStop()
11906 
    oprot.writeStructEnd()
11907 
 
11908 
  def validate(self):
11909 
    return
11910 
 
11911 
 
11912 
  def __repr__(self):
11913 
    L = ['%s=%r' % (key, value)
11914 
      for key, value in self.__dict__.iteritems()]
11915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11916 
 
11917 
  def __eq__(self, other):
11918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11919 
 
11920 
  def __ne__(self, other):
11921 
    return not (self == other)
11922 
 
5944 mandeep.dh 11923 
class deleteSimilarItem_args:
11924 
  """
11925 
  Attributes:
11926 
   - itemId
11927 
   - catalogItemId
11928 
  """
11929 
 
11930 
  thrift_spec = (
11931 
    None, # 0
11932 
    (1, TType.I64, 'itemId', None, None, ), # 1
11933 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11934 
  )
11935 
 
11936 
  def __init__(self, itemId=None, catalogItemId=None,):
11937 
    self.itemId = itemId
11938 
    self.catalogItemId = catalogItemId
11939 
 
11940 
  def read(self, iprot):
11941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11943 
      return
11944 
    iprot.readStructBegin()
11945 
    while True:
11946 
      (fname, ftype, fid) = iprot.readFieldBegin()
11947 
      if ftype == TType.STOP:
11948 
        break
11949 
      if fid == 1:
11950 
        if ftype == TType.I64:
11951 
          self.itemId = iprot.readI64();
11952 
        else:
11953 
          iprot.skip(ftype)
11954 
      elif fid == 2:
11955 
        if ftype == TType.I64:
11956 
          self.catalogItemId = iprot.readI64();
11957 
        else:
11958 
          iprot.skip(ftype)
11959 
      else:
11960 
        iprot.skip(ftype)
11961 
      iprot.readFieldEnd()
11962 
    iprot.readStructEnd()
11963 
 
11964 
  def write(self, oprot):
11965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11967 
      return
11968 
    oprot.writeStructBegin('deleteSimilarItem_args')
11969 
    if self.itemId is not None:
11970 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11971 
      oprot.writeI64(self.itemId)
11972 
      oprot.writeFieldEnd()
11973 
    if self.catalogItemId is not None:
11974 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11975 
      oprot.writeI64(self.catalogItemId)
11976 
      oprot.writeFieldEnd()
11977 
    oprot.writeFieldStop()
11978 
    oprot.writeStructEnd()
11979 
 
11980 
  def validate(self):
11981 
    return
11982 
 
11983 
 
11984 
  def __repr__(self):
11985 
    L = ['%s=%r' % (key, value)
11986 
      for key, value in self.__dict__.iteritems()]
11987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11988 
 
11989 
  def __eq__(self, other):
11990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11991 
 
11992 
  def __ne__(self, other):
11993 
    return not (self == other)
11994 
 
11995 
class deleteSimilarItem_result:
11996 
  """
11997 
  Attributes:
11998 
   - success
11999 
   - cex
12000 
  """
12001 
 
12002 
  thrift_spec = (
12003 
    (0, TType.BOOL, 'success', None, None, ), # 0
12004 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12005 
  )
12006 
 
12007 
  def __init__(self, success=None, cex=None,):
12008 
    self.success = success
12009 
    self.cex = cex
12010 
 
12011 
  def read(self, iprot):
12012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12014 
      return
12015 
    iprot.readStructBegin()
12016 
    while True:
12017 
      (fname, ftype, fid) = iprot.readFieldBegin()
12018 
      if ftype == TType.STOP:
12019 
        break
12020 
      if fid == 0:
12021 
        if ftype == TType.BOOL:
12022 
          self.success = iprot.readBool();
12023 
        else:
12024 
          iprot.skip(ftype)
12025 
      elif fid == 1:
12026 
        if ftype == TType.STRUCT:
12027 
          self.cex = CatalogServiceException()
12028 
          self.cex.read(iprot)
12029 
        else:
12030 
          iprot.skip(ftype)
12031 
      else:
12032 
        iprot.skip(ftype)
12033 
      iprot.readFieldEnd()
12034 
    iprot.readStructEnd()
12035 
 
12036 
  def write(self, oprot):
12037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12039 
      return
12040 
    oprot.writeStructBegin('deleteSimilarItem_result')
12041 
    if self.success is not None:
12042 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12043 
      oprot.writeBool(self.success)
12044 
      oprot.writeFieldEnd()
12045 
    if self.cex is not None:
12046 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12047 
      self.cex.write(oprot)
12048 
      oprot.writeFieldEnd()
12049 
    oprot.writeFieldStop()
12050 
    oprot.writeStructEnd()
12051 
 
12052 
  def validate(self):
12053 
    return
12054 
 
12055 
 
12056 
  def __repr__(self):
12057 
    L = ['%s=%r' % (key, value)
12058 
      for key, value in self.__dict__.iteritems()]
12059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12060 
 
12061 
  def __eq__(self, other):
12062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12063 
 
12064 
  def __ne__(self, other):
12065 
    return not (self == other)
12066 
 
12067 
class checkSimilarItem_args:
12068 
  """
12069 
  Attributes:
12070 
   - brand
12071 
   - modelNumber
12072 
   - modelName
12073 
   - color
12074 
  """
12075 
 
12076 
  thrift_spec = (
12077 
    None, # 0
12078 
    (1, TType.STRING, 'brand', None, None, ), # 1
12079 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
12080 
    (3, TType.STRING, 'modelName', None, None, ), # 3
12081 
    (4, TType.STRING, 'color', None, None, ), # 4
12082 
  )
12083 
 
12084 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
12085 
    self.brand = brand
12086 
    self.modelNumber = modelNumber
12087 
    self.modelName = modelName
12088 
    self.color = color
12089 
 
12090 
  def read(self, iprot):
12091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12093 
      return
12094 
    iprot.readStructBegin()
12095 
    while True:
12096 
      (fname, ftype, fid) = iprot.readFieldBegin()
12097 
      if ftype == TType.STOP:
12098 
        break
12099 
      if fid == 1:
12100 
        if ftype == TType.STRING:
12101 
          self.brand = iprot.readString();
12102 
        else:
12103 
          iprot.skip(ftype)
12104 
      elif fid == 2:
12105 
        if ftype == TType.STRING:
12106 
          self.modelNumber = iprot.readString();
12107 
        else:
12108 
          iprot.skip(ftype)
12109 
      elif fid == 3:
12110 
        if ftype == TType.STRING:
12111 
          self.modelName = iprot.readString();
12112 
        else:
12113 
          iprot.skip(ftype)
12114 
      elif fid == 4:
12115 
        if ftype == TType.STRING:
12116 
          self.color = 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('checkSimilarItem_args')
12129 
    if self.brand is not None:
12130 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
12131 
      oprot.writeString(self.brand)
12132 
      oprot.writeFieldEnd()
12133 
    if self.modelNumber is not None:
12134 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
12135 
      oprot.writeString(self.modelNumber)
12136 
      oprot.writeFieldEnd()
12137 
    if self.modelName is not None:
12138 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12139 
      oprot.writeString(self.modelName)
12140 
      oprot.writeFieldEnd()
12141 
    if self.color is not None:
12142 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12143 
      oprot.writeString(self.color)
12144 
      oprot.writeFieldEnd()
12145 
    oprot.writeFieldStop()
12146 
    oprot.writeStructEnd()
12147 
 
12148 
  def validate(self):
12149 
    return
12150 
 
12151 
 
12152 
  def __repr__(self):
12153 
    L = ['%s=%r' % (key, value)
12154 
      for key, value in self.__dict__.iteritems()]
12155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12156 
 
12157 
  def __eq__(self, other):
12158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12159 
 
12160 
  def __ne__(self, other):
12161 
    return not (self == other)
12162 
 
12163 
class checkSimilarItem_result:
12164 
  """
12165 
  Attributes:
12166 
   - success
12167 
  """
12168 
 
12169 
  thrift_spec = (
12170 
    (0, TType.I64, 'success', None, None, ), # 0
12171 
  )
12172 
 
12173 
  def __init__(self, success=None,):
12174 
    self.success = success
12175 
 
12176 
  def read(self, iprot):
12177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12179 
      return
12180 
    iprot.readStructBegin()
12181 
    while True:
12182 
      (fname, ftype, fid) = iprot.readFieldBegin()
12183 
      if ftype == TType.STOP:
12184 
        break
12185 
      if fid == 0:
12186 
        if ftype == TType.I64:
12187 
          self.success = iprot.readI64();
12188 
        else:
12189 
          iprot.skip(ftype)
12190 
      else:
12191 
        iprot.skip(ftype)
12192 
      iprot.readFieldEnd()
12193 
    iprot.readStructEnd()
12194 
 
12195 
  def write(self, oprot):
12196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12198 
      return
12199 
    oprot.writeStructBegin('checkSimilarItem_result')
12200 
    if self.success is not None:
12201 
      oprot.writeFieldBegin('success', TType.I64, 0)
12202 
      oprot.writeI64(self.success)
12203 
      oprot.writeFieldEnd()
12204 
    oprot.writeFieldStop()
12205 
    oprot.writeStructEnd()
12206 
 
12207 
  def validate(self):
12208 
    return
12209 
 
12210 
 
12211 
  def __repr__(self):
12212 
    L = ['%s=%r' % (key, value)
12213 
      for key, value in self.__dict__.iteritems()]
12214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12215 
 
12216 
  def __eq__(self, other):
12217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12218 
 
12219 
  def __ne__(self, other):
12220 
    return not (self == other)
12221 
 
12222 
class validateRiskyStatus_args:
12223 
  """
12224 
  Attributes:
12225 
   - itemId
12226 
  """
12227 
 
12228 
  thrift_spec = (
12229 
    None, # 0
12230 
    (1, TType.I64, 'itemId', None, None, ), # 1
12231 
  )
12232 
 
12233 
  def __init__(self, itemId=None,):
12234 
    self.itemId = itemId
12235 
 
12236 
  def read(self, iprot):
12237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12239 
      return
12240 
    iprot.readStructBegin()
12241 
    while True:
12242 
      (fname, ftype, fid) = iprot.readFieldBegin()
12243 
      if ftype == TType.STOP:
12244 
        break
12245 
      if fid == 1:
12246 
        if ftype == TType.I64:
12247 
          self.itemId = iprot.readI64();
12248 
        else:
12249 
          iprot.skip(ftype)
12250 
      else:
12251 
        iprot.skip(ftype)
12252 
      iprot.readFieldEnd()
12253 
    iprot.readStructEnd()
12254 
 
12255 
  def write(self, oprot):
12256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12258 
      return
12259 
    oprot.writeStructBegin('validateRiskyStatus_args')
12260 
    if self.itemId is not None:
12261 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12262 
      oprot.writeI64(self.itemId)
12263 
      oprot.writeFieldEnd()
12264 
    oprot.writeFieldStop()
12265 
    oprot.writeStructEnd()
12266 
 
12267 
  def validate(self):
12268 
    return
12269 
 
12270 
 
12271 
  def __repr__(self):
12272 
    L = ['%s=%r' % (key, value)
12273 
      for key, value in self.__dict__.iteritems()]
12274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12275 
 
12276 
  def __eq__(self, other):
12277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12278 
 
12279 
  def __ne__(self, other):
12280 
    return not (self == other)
12281 
 
12282 
class validateRiskyStatus_result:
12283 
 
12284 
  thrift_spec = (
12285 
  )
12286 
 
12287 
  def read(self, iprot):
12288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12290 
      return
12291 
    iprot.readStructBegin()
12292 
    while True:
12293 
      (fname, ftype, fid) = iprot.readFieldBegin()
12294 
      if ftype == TType.STOP:
12295 
        break
12296 
      else:
12297 
        iprot.skip(ftype)
12298 
      iprot.readFieldEnd()
12299 
    iprot.readStructEnd()
12300 
 
12301 
  def write(self, oprot):
12302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12304 
      return
12305 
    oprot.writeStructBegin('validateRiskyStatus_result')
12306 
    oprot.writeFieldStop()
12307 
    oprot.writeStructEnd()
12308 
 
12309 
  def validate(self):
12310 
    return
12311 
 
12312 
 
12313 
  def __repr__(self):
12314 
    L = ['%s=%r' % (key, value)
12315 
      for key, value in self.__dict__.iteritems()]
12316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12317 
 
12318 
  def __eq__(self, other):
12319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12320 
 
12321 
  def __ne__(self, other):
12322 
    return not (self == other)
12323 
 
12324 
class changeItemRiskyFlag_args:
12325 
  """
12326 
  Attributes:
12327 
   - itemId
12328 
   - risky
12329 
  """
12330 
 
12331 
  thrift_spec = (
12332 
    None, # 0
12333 
    (1, TType.I64, 'itemId', None, None, ), # 1
12334 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12335 
  )
12336 
 
12337 
  def __init__(self, itemId=None, risky=None,):
12338 
    self.itemId = itemId
12339 
    self.risky = risky
12340 
 
12341 
  def read(self, iprot):
12342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12344 
      return
12345 
    iprot.readStructBegin()
12346 
    while True:
12347 
      (fname, ftype, fid) = iprot.readFieldBegin()
12348 
      if ftype == TType.STOP:
12349 
        break
12350 
      if fid == 1:
12351 
        if ftype == TType.I64:
12352 
          self.itemId = iprot.readI64();
12353 
        else:
12354 
          iprot.skip(ftype)
12355 
      elif fid == 2:
12356 
        if ftype == TType.BOOL:
12357 
          self.risky = iprot.readBool();
12358 
        else:
12359 
          iprot.skip(ftype)
12360 
      else:
12361 
        iprot.skip(ftype)
12362 
      iprot.readFieldEnd()
12363 
    iprot.readStructEnd()
12364 
 
12365 
  def write(self, oprot):
12366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12368 
      return
12369 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12370 
    if self.itemId is not None:
12371 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12372 
      oprot.writeI64(self.itemId)
12373 
      oprot.writeFieldEnd()
12374 
    if self.risky is not None:
12375 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12376 
      oprot.writeBool(self.risky)
12377 
      oprot.writeFieldEnd()
12378 
    oprot.writeFieldStop()
12379 
    oprot.writeStructEnd()
12380 
 
12381 
  def validate(self):
12382 
    return
12383 
 
12384 
 
12385 
  def __repr__(self):
12386 
    L = ['%s=%r' % (key, value)
12387 
      for key, value in self.__dict__.iteritems()]
12388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12389 
 
12390 
  def __eq__(self, other):
12391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12392 
 
12393 
  def __ne__(self, other):
12394 
    return not (self == other)
12395 
 
12396 
class changeItemRiskyFlag_result:
12397 
 
12398 
  thrift_spec = (
12399 
  )
12400 
 
12401 
  def read(self, iprot):
12402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12404 
      return
12405 
    iprot.readStructBegin()
12406 
    while True:
12407 
      (fname, ftype, fid) = iprot.readFieldBegin()
12408 
      if ftype == TType.STOP:
12409 
        break
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
12419 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12420 
    oprot.writeFieldStop()
12421 
    oprot.writeStructEnd()
12422 
 
12423 
  def validate(self):
12424 
    return
12425 
 
12426 
 
12427 
  def __repr__(self):
12428 
    L = ['%s=%r' % (key, value)
12429 
      for key, value in self.__dict__.iteritems()]
12430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12431 
 
12432 
  def __eq__(self, other):
12433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12434 
 
12435 
  def __ne__(self, other):
12436 
    return not (self == other)
12437 
 
12438 
class getItemsByRiskyFlag_args:
12439 
 
12440 
  thrift_spec = (
12441 
  )
12442 
 
12443 
  def read(self, iprot):
12444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12446 
      return
12447 
    iprot.readStructBegin()
12448 
    while True:
12449 
      (fname, ftype, fid) = iprot.readFieldBegin()
12450 
      if ftype == TType.STOP:
12451 
        break
12452 
      else:
12453 
        iprot.skip(ftype)
12454 
      iprot.readFieldEnd()
12455 
    iprot.readStructEnd()
12456 
 
12457 
  def write(self, oprot):
12458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12460 
      return
12461 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12462 
    oprot.writeFieldStop()
12463 
    oprot.writeStructEnd()
12464 
 
12465 
  def validate(self):
12466 
    return
12467 
 
12468 
 
12469 
  def __repr__(self):
12470 
    L = ['%s=%r' % (key, value)
12471 
      for key, value in self.__dict__.iteritems()]
12472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12473 
 
12474 
  def __eq__(self, other):
12475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12476 
 
12477 
  def __ne__(self, other):
12478 
    return not (self == other)
12479 
 
12480 
class getItemsByRiskyFlag_result:
12481 
  """
12482 
  Attributes:
12483 
   - success
12484 
  """
12485 
 
12486 
  thrift_spec = (
12487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12488 
  )
12489 
 
12490 
  def __init__(self, success=None,):
12491 
    self.success = success
12492 
 
12493 
  def read(self, iprot):
12494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12496 
      return
12497 
    iprot.readStructBegin()
12498 
    while True:
12499 
      (fname, ftype, fid) = iprot.readFieldBegin()
12500 
      if ftype == TType.STOP:
12501 
        break
12502 
      if fid == 0:
12503 
        if ftype == TType.LIST:
12504 
          self.success = []
7438 amit.gupta 12505 
          (_etype205, _size202) = iprot.readListBegin()
12506 
          for _i206 in xrange(_size202):
12507 
            _elem207 = Item()
12508 
            _elem207.read(iprot)
12509 
            self.success.append(_elem207)
5944 mandeep.dh 12510 
          iprot.readListEnd()
12511 
        else:
12512 
          iprot.skip(ftype)
12513 
      else:
12514 
        iprot.skip(ftype)
12515 
      iprot.readFieldEnd()
12516 
    iprot.readStructEnd()
12517 
 
12518 
  def write(self, oprot):
12519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12521 
      return
12522 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12523 
    if self.success is not None:
12524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12526 
      for iter208 in self.success:
12527 
        iter208.write(oprot)
5944 mandeep.dh 12528 
      oprot.writeListEnd()
12529 
      oprot.writeFieldEnd()
12530 
    oprot.writeFieldStop()
12531 
    oprot.writeStructEnd()
12532 
 
12533 
  def validate(self):
12534 
    return
12535 
 
12536 
 
12537 
  def __repr__(self):
12538 
    L = ['%s=%r' % (key, value)
12539 
      for key, value in self.__dict__.iteritems()]
12540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12541 
 
12542 
  def __eq__(self, other):
12543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12544 
 
12545 
  def __ne__(self, other):
12546 
    return not (self == other)
12547 
 
12548 
class getItemsForMasterSheet_args:
12549 
  """
12550 
  Attributes:
12551 
   - category
12552 
   - brand
12553 
  """
12554 
 
12555 
  thrift_spec = (
12556 
    None, # 0
12557 
    (1, TType.STRING, 'category', None, None, ), # 1
12558 
    (2, TType.STRING, 'brand', None, None, ), # 2
12559 
  )
12560 
 
12561 
  def __init__(self, category=None, brand=None,):
12562 
    self.category = category
12563 
    self.brand = brand
12564 
 
12565 
  def read(self, iprot):
12566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12568 
      return
12569 
    iprot.readStructBegin()
12570 
    while True:
12571 
      (fname, ftype, fid) = iprot.readFieldBegin()
12572 
      if ftype == TType.STOP:
12573 
        break
12574 
      if fid == 1:
12575 
        if ftype == TType.STRING:
12576 
          self.category = iprot.readString();
12577 
        else:
12578 
          iprot.skip(ftype)
12579 
      elif fid == 2:
12580 
        if ftype == TType.STRING:
12581 
          self.brand = iprot.readString();
12582 
        else:
12583 
          iprot.skip(ftype)
12584 
      else:
12585 
        iprot.skip(ftype)
12586 
      iprot.readFieldEnd()
12587 
    iprot.readStructEnd()
12588 
 
12589 
  def write(self, oprot):
12590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12592 
      return
12593 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12594 
    if self.category is not None:
12595 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12596 
      oprot.writeString(self.category)
12597 
      oprot.writeFieldEnd()
12598 
    if self.brand is not None:
12599 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12600 
      oprot.writeString(self.brand)
12601 
      oprot.writeFieldEnd()
12602 
    oprot.writeFieldStop()
12603 
    oprot.writeStructEnd()
12604 
 
12605 
  def validate(self):
12606 
    return
12607 
 
12608 
 
12609 
  def __repr__(self):
12610 
    L = ['%s=%r' % (key, value)
12611 
      for key, value in self.__dict__.iteritems()]
12612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12613 
 
12614 
  def __eq__(self, other):
12615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12616 
 
12617 
  def __ne__(self, other):
12618 
    return not (self == other)
12619 
 
12620 
class getItemsForMasterSheet_result:
12621 
  """
12622 
  Attributes:
12623 
   - success
12624 
  """
12625 
 
12626 
  thrift_spec = (
12627 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12628 
  )
12629 
 
12630 
  def __init__(self, success=None,):
12631 
    self.success = success
12632 
 
12633 
  def read(self, iprot):
12634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12636 
      return
12637 
    iprot.readStructBegin()
12638 
    while True:
12639 
      (fname, ftype, fid) = iprot.readFieldBegin()
12640 
      if ftype == TType.STOP:
12641 
        break
12642 
      if fid == 0:
12643 
        if ftype == TType.LIST:
12644 
          self.success = []
7438 amit.gupta 12645 
          (_etype212, _size209) = iprot.readListBegin()
12646 
          for _i213 in xrange(_size209):
12647 
            _elem214 = Item()
12648 
            _elem214.read(iprot)
12649 
            self.success.append(_elem214)
5944 mandeep.dh 12650 
          iprot.readListEnd()
12651 
        else:
12652 
          iprot.skip(ftype)
12653 
      else:
12654 
        iprot.skip(ftype)
12655 
      iprot.readFieldEnd()
12656 
    iprot.readStructEnd()
12657 
 
12658 
  def write(self, oprot):
12659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12661 
      return
12662 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12663 
    if self.success is not None:
12664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12665 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12666 
      for iter215 in self.success:
12667 
        iter215.write(oprot)
5944 mandeep.dh 12668 
      oprot.writeListEnd()
12669 
      oprot.writeFieldEnd()
12670 
    oprot.writeFieldStop()
12671 
    oprot.writeStructEnd()
12672 
 
12673 
  def validate(self):
12674 
    return
12675 
 
12676 
 
12677 
  def __repr__(self):
12678 
    L = ['%s=%r' % (key, value)
12679 
      for key, value in self.__dict__.iteritems()]
12680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12681 
 
12682 
  def __eq__(self, other):
12683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12684 
 
12685 
  def __ne__(self, other):
12686 
    return not (self == other)
12687 
 
12688 
class getSimilarItemsCatalogIds_args:
12689 
  """
12690 
  Attributes:
12691 
   - beginIndex
12692 
   - totalItems
12693 
   - itemId
12694 
  """
12695 
 
12696 
  thrift_spec = (
12697 
    None, # 0
12698 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12699 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12700 
    (3, TType.I64, 'itemId', None, None, ), # 3
12701 
  )
12702 
 
12703 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12704 
    self.beginIndex = beginIndex
12705 
    self.totalItems = totalItems
12706 
    self.itemId = itemId
12707 
 
12708 
  def read(self, iprot):
12709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12711 
      return
12712 
    iprot.readStructBegin()
12713 
    while True:
12714 
      (fname, ftype, fid) = iprot.readFieldBegin()
12715 
      if ftype == TType.STOP:
12716 
        break
12717 
      if fid == 1:
12718 
        if ftype == TType.I64:
12719 
          self.beginIndex = iprot.readI64();
12720 
        else:
12721 
          iprot.skip(ftype)
12722 
      elif fid == 2:
12723 
        if ftype == TType.I64:
12724 
          self.totalItems = iprot.readI64();
12725 
        else:
12726 
          iprot.skip(ftype)
12727 
      elif fid == 3:
12728 
        if ftype == TType.I64:
12729 
          self.itemId = iprot.readI64();
12730 
        else:
12731 
          iprot.skip(ftype)
12732 
      else:
12733 
        iprot.skip(ftype)
12734 
      iprot.readFieldEnd()
12735 
    iprot.readStructEnd()
12736 
 
12737 
  def write(self, oprot):
12738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12740 
      return
12741 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12742 
    if self.beginIndex is not None:
12743 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12744 
      oprot.writeI64(self.beginIndex)
12745 
      oprot.writeFieldEnd()
12746 
    if self.totalItems is not None:
12747 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12748 
      oprot.writeI64(self.totalItems)
12749 
      oprot.writeFieldEnd()
12750 
    if self.itemId is not None:
12751 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12752 
      oprot.writeI64(self.itemId)
12753 
      oprot.writeFieldEnd()
12754 
    oprot.writeFieldStop()
12755 
    oprot.writeStructEnd()
12756 
 
12757 
  def validate(self):
12758 
    return
12759 
 
12760 
 
12761 
  def __repr__(self):
12762 
    L = ['%s=%r' % (key, value)
12763 
      for key, value in self.__dict__.iteritems()]
12764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12765 
 
12766 
  def __eq__(self, other):
12767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12768 
 
12769 
  def __ne__(self, other):
12770 
    return not (self == other)
12771 
 
12772 
class getSimilarItemsCatalogIds_result:
12773 
  """
12774 
  Attributes:
12775 
   - success
12776 
  """
12777 
 
12778 
  thrift_spec = (
12779 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12780 
  )
12781 
 
12782 
  def __init__(self, success=None,):
12783 
    self.success = success
12784 
 
12785 
  def read(self, iprot):
12786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12788 
      return
12789 
    iprot.readStructBegin()
12790 
    while True:
12791 
      (fname, ftype, fid) = iprot.readFieldBegin()
12792 
      if ftype == TType.STOP:
12793 
        break
12794 
      if fid == 0:
12795 
        if ftype == TType.LIST:
12796 
          self.success = []
7438 amit.gupta 12797 
          (_etype219, _size216) = iprot.readListBegin()
12798 
          for _i220 in xrange(_size216):
12799 
            _elem221 = iprot.readI64();
12800 
            self.success.append(_elem221)
5944 mandeep.dh 12801 
          iprot.readListEnd()
12802 
        else:
12803 
          iprot.skip(ftype)
12804 
      else:
12805 
        iprot.skip(ftype)
12806 
      iprot.readFieldEnd()
12807 
    iprot.readStructEnd()
12808 
 
12809 
  def write(self, oprot):
12810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12812 
      return
12813 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12814 
    if self.success is not None:
12815 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12816 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12817 
      for iter222 in self.success:
12818 
        oprot.writeI64(iter222)
5944 mandeep.dh 12819 
      oprot.writeListEnd()
12820 
      oprot.writeFieldEnd()
12821 
    oprot.writeFieldStop()
12822 
    oprot.writeStructEnd()
12823 
 
12824 
  def validate(self):
12825 
    return
12826 
 
12827 
 
12828 
  def __repr__(self):
12829 
    L = ['%s=%r' % (key, value)
12830 
      for key, value in self.__dict__.iteritems()]
12831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12832 
 
12833 
  def __eq__(self, other):
12834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12835 
 
12836 
  def __ne__(self, other):
12837 
    return not (self == other)
12838 
 
12839 
class addProductNotification_args:
12840 
  """
12841 
  Attributes:
12842 
   - itemId
12843 
   - email
12844 
  """
12845 
 
12846 
  thrift_spec = None
12847 
  def __init__(self, itemId=None, email=None,):
12848 
    self.itemId = itemId
12849 
    self.email = email
12850 
 
12851 
  def read(self, iprot):
12852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12854 
      return
12855 
    iprot.readStructBegin()
12856 
    while True:
12857 
      (fname, ftype, fid) = iprot.readFieldBegin()
12858 
      if ftype == TType.STOP:
12859 
        break
12860 
      if fid == -1:
12861 
        if ftype == TType.I64:
12862 
          self.itemId = iprot.readI64();
12863 
        else:
12864 
          iprot.skip(ftype)
12865 
      elif fid == -2:
12866 
        if ftype == TType.STRING:
12867 
          self.email = iprot.readString();
12868 
        else:
12869 
          iprot.skip(ftype)
12870 
      else:
12871 
        iprot.skip(ftype)
12872 
      iprot.readFieldEnd()
12873 
    iprot.readStructEnd()
12874 
 
12875 
  def write(self, oprot):
12876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12878 
      return
12879 
    oprot.writeStructBegin('addProductNotification_args')
12880 
    if self.email is not None:
12881 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12882 
      oprot.writeString(self.email)
12883 
      oprot.writeFieldEnd()
12884 
    if self.itemId is not None:
12885 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12886 
      oprot.writeI64(self.itemId)
12887 
      oprot.writeFieldEnd()
12888 
    oprot.writeFieldStop()
12889 
    oprot.writeStructEnd()
12890 
 
12891 
  def validate(self):
12892 
    return
12893 
 
12894 
 
12895 
  def __repr__(self):
12896 
    L = ['%s=%r' % (key, value)
12897 
      for key, value in self.__dict__.iteritems()]
12898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12899 
 
12900 
  def __eq__(self, other):
12901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12902 
 
12903 
  def __ne__(self, other):
12904 
    return not (self == other)
12905 
 
12906 
class addProductNotification_result:
12907 
  """
12908 
  Attributes:
12909 
   - success
12910 
  """
12911 
 
12912 
  thrift_spec = (
12913 
    (0, TType.BOOL, 'success', None, None, ), # 0
12914 
  )
12915 
 
12916 
  def __init__(self, success=None,):
12917 
    self.success = success
12918 
 
12919 
  def read(self, iprot):
12920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12922 
      return
12923 
    iprot.readStructBegin()
12924 
    while True:
12925 
      (fname, ftype, fid) = iprot.readFieldBegin()
12926 
      if ftype == TType.STOP:
12927 
        break
12928 
      if fid == 0:
12929 
        if ftype == TType.BOOL:
12930 
          self.success = iprot.readBool();
12931 
        else:
12932 
          iprot.skip(ftype)
12933 
      else:
12934 
        iprot.skip(ftype)
12935 
      iprot.readFieldEnd()
12936 
    iprot.readStructEnd()
12937 
 
12938 
  def write(self, oprot):
12939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12941 
      return
12942 
    oprot.writeStructBegin('addProductNotification_result')
12943 
    if self.success is not None:
12944 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12945 
      oprot.writeBool(self.success)
12946 
      oprot.writeFieldEnd()
12947 
    oprot.writeFieldStop()
12948 
    oprot.writeStructEnd()
12949 
 
12950 
  def validate(self):
12951 
    return
12952 
 
12953 
 
12954 
  def __repr__(self):
12955 
    L = ['%s=%r' % (key, value)
12956 
      for key, value in self.__dict__.iteritems()]
12957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12958 
 
12959 
  def __eq__(self, other):
12960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12961 
 
12962 
  def __ne__(self, other):
12963 
    return not (self == other)
12964 
 
12965 
class sendProductNotifications_args:
12966 
 
12967 
  thrift_spec = (
12968 
  )
12969 
 
12970 
  def read(self, iprot):
12971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12973 
      return
12974 
    iprot.readStructBegin()
12975 
    while True:
12976 
      (fname, ftype, fid) = iprot.readFieldBegin()
12977 
      if ftype == TType.STOP:
12978 
        break
12979 
      else:
12980 
        iprot.skip(ftype)
12981 
      iprot.readFieldEnd()
12982 
    iprot.readStructEnd()
12983 
 
12984 
  def write(self, oprot):
12985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12987 
      return
12988 
    oprot.writeStructBegin('sendProductNotifications_args')
12989 
    oprot.writeFieldStop()
12990 
    oprot.writeStructEnd()
12991 
 
12992 
  def validate(self):
12993 
    return
12994 
 
12995 
 
12996 
  def __repr__(self):
12997 
    L = ['%s=%r' % (key, value)
12998 
      for key, value in self.__dict__.iteritems()]
12999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13000 
 
13001 
  def __eq__(self, other):
13002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13003 
 
13004 
  def __ne__(self, other):
13005 
    return not (self == other)
13006 
 
13007 
class sendProductNotifications_result:
13008 
  """
13009 
  Attributes:
13010 
   - success
13011 
  """
13012 
 
13013 
  thrift_spec = (
13014 
    (0, TType.BOOL, 'success', None, None, ), # 0
13015 
  )
13016 
 
13017 
  def __init__(self, success=None,):
13018 
    self.success = success
13019 
 
13020 
  def read(self, iprot):
13021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13023 
      return
13024 
    iprot.readStructBegin()
13025 
    while True:
13026 
      (fname, ftype, fid) = iprot.readFieldBegin()
13027 
      if ftype == TType.STOP:
13028 
        break
13029 
      if fid == 0:
13030 
        if ftype == TType.BOOL:
13031 
          self.success = iprot.readBool();
13032 
        else:
13033 
          iprot.skip(ftype)
13034 
      else:
13035 
        iprot.skip(ftype)
13036 
      iprot.readFieldEnd()
13037 
    iprot.readStructEnd()
13038 
 
13039 
  def write(self, oprot):
13040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13042 
      return
13043 
    oprot.writeStructBegin('sendProductNotifications_result')
13044 
    if self.success is not None:
13045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13046 
      oprot.writeBool(self.success)
13047 
      oprot.writeFieldEnd()
13048 
    oprot.writeFieldStop()
13049 
    oprot.writeStructEnd()
13050 
 
13051 
  def validate(self):
13052 
    return
13053 
 
13054 
 
13055 
  def __repr__(self):
13056 
    L = ['%s=%r' % (key, value)
13057 
      for key, value in self.__dict__.iteritems()]
13058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13059 
 
13060 
  def __eq__(self, other):
13061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13062 
 
13063 
  def __ne__(self, other):
13064 
    return not (self == other)
13065 
 
13066 
class getAllBrandsByCategory_args:
13067 
  """
13068 
  Attributes:
13069 
   - categoryId
13070 
  """
13071 
 
13072 
  thrift_spec = (
13073 
    None, # 0
13074 
    (1, TType.I64, 'categoryId', None, None, ), # 1
13075 
  )
13076 
 
13077 
  def __init__(self, categoryId=None,):
13078 
    self.categoryId = categoryId
13079 
 
13080 
  def read(self, iprot):
13081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13083 
      return
13084 
    iprot.readStructBegin()
13085 
    while True:
13086 
      (fname, ftype, fid) = iprot.readFieldBegin()
13087 
      if ftype == TType.STOP:
13088 
        break
13089 
      if fid == 1:
13090 
        if ftype == TType.I64:
13091 
          self.categoryId = iprot.readI64();
13092 
        else:
13093 
          iprot.skip(ftype)
13094 
      else:
13095 
        iprot.skip(ftype)
13096 
      iprot.readFieldEnd()
13097 
    iprot.readStructEnd()
13098 
 
13099 
  def write(self, oprot):
13100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13102 
      return
13103 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
13104 
    if self.categoryId is not None:
13105 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
13106 
      oprot.writeI64(self.categoryId)
13107 
      oprot.writeFieldEnd()
13108 
    oprot.writeFieldStop()
13109 
    oprot.writeStructEnd()
13110 
 
13111 
  def validate(self):
13112 
    return
13113 
 
13114 
 
13115 
  def __repr__(self):
13116 
    L = ['%s=%r' % (key, value)
13117 
      for key, value in self.__dict__.iteritems()]
13118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13119 
 
13120 
  def __eq__(self, other):
13121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13122 
 
13123 
  def __ne__(self, other):
13124 
    return not (self == other)
13125 
 
13126 
class getAllBrandsByCategory_result:
13127 
  """
13128 
  Attributes:
13129 
   - success
13130 
  """
13131 
 
13132 
  thrift_spec = (
13133 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13134 
  )
13135 
 
13136 
  def __init__(self, success=None,):
13137 
    self.success = success
13138 
 
13139 
  def read(self, iprot):
13140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13142 
      return
13143 
    iprot.readStructBegin()
13144 
    while True:
13145 
      (fname, ftype, fid) = iprot.readFieldBegin()
13146 
      if ftype == TType.STOP:
13147 
        break
13148 
      if fid == 0:
13149 
        if ftype == TType.LIST:
13150 
          self.success = []
7438 amit.gupta 13151 
          (_etype226, _size223) = iprot.readListBegin()
13152 
          for _i227 in xrange(_size223):
13153 
            _elem228 = iprot.readString();
13154 
            self.success.append(_elem228)
5944 mandeep.dh 13155 
          iprot.readListEnd()
13156 
        else:
13157 
          iprot.skip(ftype)
13158 
      else:
13159 
        iprot.skip(ftype)
13160 
      iprot.readFieldEnd()
13161 
    iprot.readStructEnd()
13162 
 
13163 
  def write(self, oprot):
13164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13166 
      return
13167 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
13168 
    if self.success is not None:
13169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13170 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13171 
      for iter229 in self.success:
13172 
        oprot.writeString(iter229)
5944 mandeep.dh 13173 
      oprot.writeListEnd()
13174 
      oprot.writeFieldEnd()
13175 
    oprot.writeFieldStop()
13176 
    oprot.writeStructEnd()
13177 
 
13178 
  def validate(self):
13179 
    return
13180 
 
13181 
 
13182 
  def __repr__(self):
13183 
    L = ['%s=%r' % (key, value)
13184 
      for key, value in self.__dict__.iteritems()]
13185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13186 
 
13187 
  def __eq__(self, other):
13188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13189 
 
13190 
  def __ne__(self, other):
13191 
    return not (self == other)
13192 
 
13193 
class getAllBrands_args:
13194 
 
13195 
  thrift_spec = (
13196 
  )
13197 
 
13198 
  def read(self, iprot):
13199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13201 
      return
13202 
    iprot.readStructBegin()
13203 
    while True:
13204 
      (fname, ftype, fid) = iprot.readFieldBegin()
13205 
      if ftype == TType.STOP:
13206 
        break
13207 
      else:
13208 
        iprot.skip(ftype)
13209 
      iprot.readFieldEnd()
13210 
    iprot.readStructEnd()
13211 
 
13212 
  def write(self, oprot):
13213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13215 
      return
13216 
    oprot.writeStructBegin('getAllBrands_args')
13217 
    oprot.writeFieldStop()
13218 
    oprot.writeStructEnd()
13219 
 
13220 
  def validate(self):
13221 
    return
13222 
 
13223 
 
13224 
  def __repr__(self):
13225 
    L = ['%s=%r' % (key, value)
13226 
      for key, value in self.__dict__.iteritems()]
13227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13228 
 
13229 
  def __eq__(self, other):
13230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13231 
 
13232 
  def __ne__(self, other):
13233 
    return not (self == other)
13234 
 
13235 
class getAllBrands_result:
13236 
  """
13237 
  Attributes:
13238 
   - success
13239 
  """
13240 
 
13241 
  thrift_spec = (
13242 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13243 
  )
13244 
 
13245 
  def __init__(self, success=None,):
13246 
    self.success = success
13247 
 
13248 
  def read(self, iprot):
13249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13251 
      return
13252 
    iprot.readStructBegin()
13253 
    while True:
13254 
      (fname, ftype, fid) = iprot.readFieldBegin()
13255 
      if ftype == TType.STOP:
13256 
        break
13257 
      if fid == 0:
13258 
        if ftype == TType.LIST:
13259 
          self.success = []
7438 amit.gupta 13260 
          (_etype233, _size230) = iprot.readListBegin()
13261 
          for _i234 in xrange(_size230):
13262 
            _elem235 = iprot.readString();
13263 
            self.success.append(_elem235)
5944 mandeep.dh 13264 
          iprot.readListEnd()
13265 
        else:
13266 
          iprot.skip(ftype)
13267 
      else:
13268 
        iprot.skip(ftype)
13269 
      iprot.readFieldEnd()
13270 
    iprot.readStructEnd()
13271 
 
13272 
  def write(self, oprot):
13273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13275 
      return
13276 
    oprot.writeStructBegin('getAllBrands_result')
13277 
    if self.success is not None:
13278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13279 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13280 
      for iter236 in self.success:
13281 
        oprot.writeString(iter236)
5944 mandeep.dh 13282 
      oprot.writeListEnd()
13283 
      oprot.writeFieldEnd()
13284 
    oprot.writeFieldStop()
13285 
    oprot.writeStructEnd()
13286 
 
13287 
  def validate(self):
13288 
    return
13289 
 
13290 
 
13291 
  def __repr__(self):
13292 
    L = ['%s=%r' % (key, value)
13293 
      for key, value in self.__dict__.iteritems()]
13294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13295 
 
13296 
  def __eq__(self, other):
13297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13298 
 
13299 
  def __ne__(self, other):
13300 
    return not (self == other)
13301 
 
13302 
class getAllSources_args:
13303 
 
13304 
  thrift_spec = (
13305 
  )
13306 
 
13307 
  def read(self, iprot):
13308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13310 
      return
13311 
    iprot.readStructBegin()
13312 
    while True:
13313 
      (fname, ftype, fid) = iprot.readFieldBegin()
13314 
      if ftype == TType.STOP:
13315 
        break
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('getAllSources_args')
13326 
    oprot.writeFieldStop()
13327 
    oprot.writeStructEnd()
13328 
 
13329 
  def validate(self):
13330 
    return
13331 
 
13332 
 
13333 
  def __repr__(self):
13334 
    L = ['%s=%r' % (key, value)
13335 
      for key, value in self.__dict__.iteritems()]
13336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13337 
 
13338 
  def __eq__(self, other):
13339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13340 
 
13341 
  def __ne__(self, other):
13342 
    return not (self == other)
13343 
 
13344 
class getAllSources_result:
13345 
  """
13346 
  Attributes:
13347 
   - success
13348 
  """
13349 
 
13350 
  thrift_spec = (
13351 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13352 
  )
13353 
 
13354 
  def __init__(self, success=None,):
13355 
    self.success = success
13356 
 
13357 
  def read(self, iprot):
13358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13360 
      return
13361 
    iprot.readStructBegin()
13362 
    while True:
13363 
      (fname, ftype, fid) = iprot.readFieldBegin()
13364 
      if ftype == TType.STOP:
13365 
        break
13366 
      if fid == 0:
13367 
        if ftype == TType.LIST:
13368 
          self.success = []
7438 amit.gupta 13369 
          (_etype240, _size237) = iprot.readListBegin()
13370 
          for _i241 in xrange(_size237):
13371 
            _elem242 = Source()
13372 
            _elem242.read(iprot)
13373 
            self.success.append(_elem242)
5944 mandeep.dh 13374 
          iprot.readListEnd()
13375 
        else:
13376 
          iprot.skip(ftype)
13377 
      else:
13378 
        iprot.skip(ftype)
13379 
      iprot.readFieldEnd()
13380 
    iprot.readStructEnd()
13381 
 
13382 
  def write(self, oprot):
13383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13385 
      return
13386 
    oprot.writeStructBegin('getAllSources_result')
13387 
    if self.success is not None:
13388 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13389 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13390 
      for iter243 in self.success:
13391 
        iter243.write(oprot)
5944 mandeep.dh 13392 
      oprot.writeListEnd()
13393 
      oprot.writeFieldEnd()
13394 
    oprot.writeFieldStop()
13395 
    oprot.writeStructEnd()
13396 
 
13397 
  def validate(self):
13398 
    return
13399 
 
13400 
 
13401 
  def __repr__(self):
13402 
    L = ['%s=%r' % (key, value)
13403 
      for key, value in self.__dict__.iteritems()]
13404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13405 
 
13406 
  def __eq__(self, other):
13407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13408 
 
13409 
  def __ne__(self, other):
13410 
    return not (self == other)
13411 
 
13412 
class getItemPricingBySource_args:
13413 
  """
13414 
  Attributes:
13415 
   - itemId
13416 
   - sourceId
13417 
  """
13418 
 
13419 
  thrift_spec = (
13420 
    None, # 0
13421 
    (1, TType.I64, 'itemId', None, None, ), # 1
13422 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13423 
  )
13424 
 
13425 
  def __init__(self, itemId=None, sourceId=None,):
13426 
    self.itemId = itemId
13427 
    self.sourceId = sourceId
13428 
 
13429 
  def read(self, iprot):
13430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13432 
      return
13433 
    iprot.readStructBegin()
13434 
    while True:
13435 
      (fname, ftype, fid) = iprot.readFieldBegin()
13436 
      if ftype == TType.STOP:
13437 
        break
13438 
      if fid == 1:
13439 
        if ftype == TType.I64:
13440 
          self.itemId = iprot.readI64();
13441 
        else:
13442 
          iprot.skip(ftype)
13443 
      elif fid == 2:
13444 
        if ftype == TType.I64:
13445 
          self.sourceId = iprot.readI64();
13446 
        else:
13447 
          iprot.skip(ftype)
13448 
      else:
13449 
        iprot.skip(ftype)
13450 
      iprot.readFieldEnd()
13451 
    iprot.readStructEnd()
13452 
 
13453 
  def write(self, oprot):
13454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13456 
      return
13457 
    oprot.writeStructBegin('getItemPricingBySource_args')
13458 
    if self.itemId is not None:
13459 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13460 
      oprot.writeI64(self.itemId)
13461 
      oprot.writeFieldEnd()
13462 
    if self.sourceId is not None:
13463 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13464 
      oprot.writeI64(self.sourceId)
13465 
      oprot.writeFieldEnd()
13466 
    oprot.writeFieldStop()
13467 
    oprot.writeStructEnd()
13468 
 
13469 
  def validate(self):
13470 
    return
13471 
 
13472 
 
13473 
  def __repr__(self):
13474 
    L = ['%s=%r' % (key, value)
13475 
      for key, value in self.__dict__.iteritems()]
13476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13477 
 
13478 
  def __eq__(self, other):
13479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13480 
 
13481 
  def __ne__(self, other):
13482 
    return not (self == other)
13483 
 
13484 
class getItemPricingBySource_result:
13485 
  """
13486 
  Attributes:
13487 
   - success
13488 
   - cex
13489 
  """
13490 
 
13491 
  thrift_spec = (
13492 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13493 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13494 
  )
13495 
 
13496 
  def __init__(self, success=None, cex=None,):
13497 
    self.success = success
13498 
    self.cex = cex
13499 
 
13500 
  def read(self, iprot):
13501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13503 
      return
13504 
    iprot.readStructBegin()
13505 
    while True:
13506 
      (fname, ftype, fid) = iprot.readFieldBegin()
13507 
      if ftype == TType.STOP:
13508 
        break
13509 
      if fid == 0:
13510 
        if ftype == TType.STRUCT:
13511 
          self.success = SourceItemPricing()
13512 
          self.success.read(iprot)
13513 
        else:
13514 
          iprot.skip(ftype)
13515 
      elif fid == 1:
13516 
        if ftype == TType.STRUCT:
13517 
          self.cex = CatalogServiceException()
13518 
          self.cex.read(iprot)
13519 
        else:
13520 
          iprot.skip(ftype)
13521 
      else:
13522 
        iprot.skip(ftype)
13523 
      iprot.readFieldEnd()
13524 
    iprot.readStructEnd()
13525 
 
13526 
  def write(self, oprot):
13527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13529 
      return
13530 
    oprot.writeStructBegin('getItemPricingBySource_result')
13531 
    if self.success is not None:
13532 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13533 
      self.success.write(oprot)
13534 
      oprot.writeFieldEnd()
13535 
    if self.cex is not None:
13536 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13537 
      self.cex.write(oprot)
13538 
      oprot.writeFieldEnd()
13539 
    oprot.writeFieldStop()
13540 
    oprot.writeStructEnd()
13541 
 
13542 
  def validate(self):
13543 
    return
13544 
 
13545 
 
13546 
  def __repr__(self):
13547 
    L = ['%s=%r' % (key, value)
13548 
      for key, value in self.__dict__.iteritems()]
13549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13550 
 
13551 
  def __eq__(self, other):
13552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13553 
 
13554 
  def __ne__(self, other):
13555 
    return not (self == other)
13556 
 
13557 
class addSourceItemPricing_args:
13558 
  """
13559 
  Attributes:
13560 
   - sourceItemPricing
13561 
  """
13562 
 
13563 
  thrift_spec = (
13564 
    None, # 0
13565 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13566 
  )
13567 
 
13568 
  def __init__(self, sourceItemPricing=None,):
13569 
    self.sourceItemPricing = sourceItemPricing
13570 
 
13571 
  def read(self, iprot):
13572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13574 
      return
13575 
    iprot.readStructBegin()
13576 
    while True:
13577 
      (fname, ftype, fid) = iprot.readFieldBegin()
13578 
      if ftype == TType.STOP:
13579 
        break
13580 
      if fid == 1:
13581 
        if ftype == TType.STRUCT:
13582 
          self.sourceItemPricing = SourceItemPricing()
13583 
          self.sourceItemPricing.read(iprot)
13584 
        else:
13585 
          iprot.skip(ftype)
13586 
      else:
13587 
        iprot.skip(ftype)
13588 
      iprot.readFieldEnd()
13589 
    iprot.readStructEnd()
13590 
 
13591 
  def write(self, oprot):
13592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13594 
      return
13595 
    oprot.writeStructBegin('addSourceItemPricing_args')
13596 
    if self.sourceItemPricing is not None:
13597 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13598 
      self.sourceItemPricing.write(oprot)
13599 
      oprot.writeFieldEnd()
13600 
    oprot.writeFieldStop()
13601 
    oprot.writeStructEnd()
13602 
 
13603 
  def validate(self):
13604 
    return
13605 
 
13606 
 
13607 
  def __repr__(self):
13608 
    L = ['%s=%r' % (key, value)
13609 
      for key, value in self.__dict__.iteritems()]
13610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13611 
 
13612 
  def __eq__(self, other):
13613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13614 
 
13615 
  def __ne__(self, other):
13616 
    return not (self == other)
13617 
 
13618 
class addSourceItemPricing_result:
13619 
  """
13620 
  Attributes:
13621 
   - cex
13622 
  """
13623 
 
13624 
  thrift_spec = (
13625 
    None, # 0
13626 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13627 
  )
13628 
 
13629 
  def __init__(self, cex=None,):
13630 
    self.cex = cex
13631 
 
13632 
  def read(self, iprot):
13633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13635 
      return
13636 
    iprot.readStructBegin()
13637 
    while True:
13638 
      (fname, ftype, fid) = iprot.readFieldBegin()
13639 
      if ftype == TType.STOP:
13640 
        break
13641 
      if fid == 1:
13642 
        if ftype == TType.STRUCT:
13643 
          self.cex = CatalogServiceException()
13644 
          self.cex.read(iprot)
13645 
        else:
13646 
          iprot.skip(ftype)
13647 
      else:
13648 
        iprot.skip(ftype)
13649 
      iprot.readFieldEnd()
13650 
    iprot.readStructEnd()
13651 
 
13652 
  def write(self, oprot):
13653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13655 
      return
13656 
    oprot.writeStructBegin('addSourceItemPricing_result')
13657 
    if self.cex is not None:
13658 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13659 
      self.cex.write(oprot)
13660 
      oprot.writeFieldEnd()
13661 
    oprot.writeFieldStop()
13662 
    oprot.writeStructEnd()
13663 
 
13664 
  def validate(self):
13665 
    return
13666 
 
13667 
 
13668 
  def __repr__(self):
13669 
    L = ['%s=%r' % (key, value)
13670 
      for key, value in self.__dict__.iteritems()]
13671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13672 
 
13673 
  def __eq__(self, other):
13674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13675 
 
13676 
  def __ne__(self, other):
13677 
    return not (self == other)
13678 
 
13679 
class getAllSourcePricing_args:
13680 
  """
13681 
  Attributes:
13682 
   - itemId
13683 
  """
13684 
 
13685 
  thrift_spec = (
13686 
    None, # 0
13687 
    (1, TType.I64, 'itemId', None, None, ), # 1
13688 
  )
13689 
 
13690 
  def __init__(self, itemId=None,):
13691 
    self.itemId = itemId
13692 
 
13693 
  def read(self, iprot):
13694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13696 
      return
13697 
    iprot.readStructBegin()
13698 
    while True:
13699 
      (fname, ftype, fid) = iprot.readFieldBegin()
13700 
      if ftype == TType.STOP:
13701 
        break
13702 
      if fid == 1:
13703 
        if ftype == TType.I64:
13704 
          self.itemId = iprot.readI64();
13705 
        else:
13706 
          iprot.skip(ftype)
13707 
      else:
13708 
        iprot.skip(ftype)
13709 
      iprot.readFieldEnd()
13710 
    iprot.readStructEnd()
13711 
 
13712 
  def write(self, oprot):
13713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13715 
      return
13716 
    oprot.writeStructBegin('getAllSourcePricing_args')
13717 
    if self.itemId is not None:
13718 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13719 
      oprot.writeI64(self.itemId)
13720 
      oprot.writeFieldEnd()
13721 
    oprot.writeFieldStop()
13722 
    oprot.writeStructEnd()
13723 
 
13724 
  def validate(self):
13725 
    return
13726 
 
13727 
 
13728 
  def __repr__(self):
13729 
    L = ['%s=%r' % (key, value)
13730 
      for key, value in self.__dict__.iteritems()]
13731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13732 
 
13733 
  def __eq__(self, other):
13734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13735 
 
13736 
  def __ne__(self, other):
13737 
    return not (self == other)
13738 
 
13739 
class getAllSourcePricing_result:
13740 
  """
13741 
  Attributes:
13742 
   - success
13743 
   - cex
13744 
  """
13745 
 
13746 
  thrift_spec = (
13747 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13748 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13749 
  )
13750 
 
13751 
  def __init__(self, success=None, cex=None,):
13752 
    self.success = success
13753 
    self.cex = cex
13754 
 
13755 
  def read(self, iprot):
13756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13758 
      return
13759 
    iprot.readStructBegin()
13760 
    while True:
13761 
      (fname, ftype, fid) = iprot.readFieldBegin()
13762 
      if ftype == TType.STOP:
13763 
        break
13764 
      if fid == 0:
13765 
        if ftype == TType.LIST:
13766 
          self.success = []
7438 amit.gupta 13767 
          (_etype247, _size244) = iprot.readListBegin()
13768 
          for _i248 in xrange(_size244):
13769 
            _elem249 = SourceItemPricing()
13770 
            _elem249.read(iprot)
13771 
            self.success.append(_elem249)
5944 mandeep.dh 13772 
          iprot.readListEnd()
13773 
        else:
13774 
          iprot.skip(ftype)
13775 
      elif fid == 1:
13776 
        if ftype == TType.STRUCT:
13777 
          self.cex = CatalogServiceException()
13778 
          self.cex.read(iprot)
13779 
        else:
13780 
          iprot.skip(ftype)
13781 
      else:
13782 
        iprot.skip(ftype)
13783 
      iprot.readFieldEnd()
13784 
    iprot.readStructEnd()
13785 
 
13786 
  def write(self, oprot):
13787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13789 
      return
13790 
    oprot.writeStructBegin('getAllSourcePricing_result')
13791 
    if self.success is not None:
13792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13794 
      for iter250 in self.success:
13795 
        iter250.write(oprot)
5944 mandeep.dh 13796 
      oprot.writeListEnd()
13797 
      oprot.writeFieldEnd()
13798 
    if self.cex is not None:
13799 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13800 
      self.cex.write(oprot)
13801 
      oprot.writeFieldEnd()
13802 
    oprot.writeFieldStop()
13803 
    oprot.writeStructEnd()
13804 
 
13805 
  def validate(self):
13806 
    return
13807 
 
13808 
 
13809 
  def __repr__(self):
13810 
    L = ['%s=%r' % (key, value)
13811 
      for key, value in self.__dict__.iteritems()]
13812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13813 
 
13814 
  def __eq__(self, other):
13815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13816 
 
13817 
  def __ne__(self, other):
13818 
    return not (self == other)
13819 
 
13820 
class getItemForSource_args:
13821 
  """
13822 
  Attributes:
13823 
   - item_id
13824 
   - sourceId
13825 
  """
13826 
 
13827 
  thrift_spec = (
13828 
    None, # 0
13829 
    (1, TType.I64, 'item_id', None, None, ), # 1
13830 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13831 
  )
13832 
 
13833 
  def __init__(self, item_id=None, sourceId=None,):
13834 
    self.item_id = item_id
13835 
    self.sourceId = sourceId
13836 
 
13837 
  def read(self, iprot):
13838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13840 
      return
13841 
    iprot.readStructBegin()
13842 
    while True:
13843 
      (fname, ftype, fid) = iprot.readFieldBegin()
13844 
      if ftype == TType.STOP:
13845 
        break
13846 
      if fid == 1:
13847 
        if ftype == TType.I64:
13848 
          self.item_id = iprot.readI64();
13849 
        else:
13850 
          iprot.skip(ftype)
13851 
      elif fid == 2:
13852 
        if ftype == TType.I64:
13853 
          self.sourceId = iprot.readI64();
13854 
        else:
13855 
          iprot.skip(ftype)
13856 
      else:
13857 
        iprot.skip(ftype)
13858 
      iprot.readFieldEnd()
13859 
    iprot.readStructEnd()
13860 
 
13861 
  def write(self, oprot):
13862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13864 
      return
13865 
    oprot.writeStructBegin('getItemForSource_args')
13866 
    if self.item_id is not None:
13867 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13868 
      oprot.writeI64(self.item_id)
13869 
      oprot.writeFieldEnd()
13870 
    if self.sourceId is not None:
13871 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13872 
      oprot.writeI64(self.sourceId)
13873 
      oprot.writeFieldEnd()
13874 
    oprot.writeFieldStop()
13875 
    oprot.writeStructEnd()
13876 
 
13877 
  def validate(self):
13878 
    return
13879 
 
13880 
 
13881 
  def __repr__(self):
13882 
    L = ['%s=%r' % (key, value)
13883 
      for key, value in self.__dict__.iteritems()]
13884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13885 
 
13886 
  def __eq__(self, other):
13887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13888 
 
13889 
  def __ne__(self, other):
13890 
    return not (self == other)
13891 
 
13892 
class getItemForSource_result:
13893 
  """
13894 
  Attributes:
13895 
   - success
13896 
   - cex
13897 
  """
13898 
 
13899 
  thrift_spec = (
13900 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13901 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13902 
  )
13903 
 
13904 
  def __init__(self, success=None, cex=None,):
13905 
    self.success = success
13906 
    self.cex = cex
13907 
 
13908 
  def read(self, iprot):
13909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13911 
      return
13912 
    iprot.readStructBegin()
13913 
    while True:
13914 
      (fname, ftype, fid) = iprot.readFieldBegin()
13915 
      if ftype == TType.STOP:
13916 
        break
13917 
      if fid == 0:
13918 
        if ftype == TType.STRUCT:
13919 
          self.success = Item()
13920 
          self.success.read(iprot)
13921 
        else:
13922 
          iprot.skip(ftype)
13923 
      elif fid == 1:
13924 
        if ftype == TType.STRUCT:
13925 
          self.cex = CatalogServiceException()
13926 
          self.cex.read(iprot)
13927 
        else:
13928 
          iprot.skip(ftype)
13929 
      else:
13930 
        iprot.skip(ftype)
13931 
      iprot.readFieldEnd()
13932 
    iprot.readStructEnd()
13933 
 
13934 
  def write(self, oprot):
13935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13937 
      return
13938 
    oprot.writeStructBegin('getItemForSource_result')
13939 
    if self.success is not None:
13940 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13941 
      self.success.write(oprot)
13942 
      oprot.writeFieldEnd()
13943 
    if self.cex is not None:
13944 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13945 
      self.cex.write(oprot)
13946 
      oprot.writeFieldEnd()
13947 
    oprot.writeFieldStop()
13948 
    oprot.writeStructEnd()
13949 
 
13950 
  def validate(self):
13951 
    return
13952 
 
13953 
 
13954 
  def __repr__(self):
13955 
    L = ['%s=%r' % (key, value)
13956 
      for key, value in self.__dict__.iteritems()]
13957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13958 
 
13959 
  def __eq__(self, other):
13960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13961 
 
13962 
  def __ne__(self, other):
13963 
    return not (self == other)
13964 
 
13965 
class searchItemsInRange_args:
13966 
  """
13967 
  Attributes:
13968 
   - searchTerms
13969 
   - offset
13970 
   - limit
13971 
  """
13972 
 
13973 
  thrift_spec = (
13974 
    None, # 0
13975 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13976 
    (2, TType.I64, 'offset', None, None, ), # 2
13977 
    (3, TType.I64, 'limit', None, None, ), # 3
13978 
  )
13979 
 
13980 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13981 
    self.searchTerms = searchTerms
13982 
    self.offset = offset
13983 
    self.limit = limit
13984 
 
13985 
  def read(self, iprot):
13986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13988 
      return
13989 
    iprot.readStructBegin()
13990 
    while True:
13991 
      (fname, ftype, fid) = iprot.readFieldBegin()
13992 
      if ftype == TType.STOP:
13993 
        break
13994 
      if fid == 1:
13995 
        if ftype == TType.LIST:
13996 
          self.searchTerms = []
7438 amit.gupta 13997 
          (_etype254, _size251) = iprot.readListBegin()
13998 
          for _i255 in xrange(_size251):
13999 
            _elem256 = iprot.readString();
14000 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 14001 
          iprot.readListEnd()
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      elif fid == 2:
14005 
        if ftype == TType.I64:
14006 
          self.offset = iprot.readI64();
14007 
        else:
14008 
          iprot.skip(ftype)
14009 
      elif fid == 3:
14010 
        if ftype == TType.I64:
14011 
          self.limit = iprot.readI64();
14012 
        else:
14013 
          iprot.skip(ftype)
14014 
      else:
14015 
        iprot.skip(ftype)
14016 
      iprot.readFieldEnd()
14017 
    iprot.readStructEnd()
14018 
 
14019 
  def write(self, oprot):
14020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14022 
      return
14023 
    oprot.writeStructBegin('searchItemsInRange_args')
14024 
    if self.searchTerms is not None:
14025 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14026 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14027 
      for iter257 in self.searchTerms:
14028 
        oprot.writeString(iter257)
5944 mandeep.dh 14029 
      oprot.writeListEnd()
14030 
      oprot.writeFieldEnd()
14031 
    if self.offset is not None:
14032 
      oprot.writeFieldBegin('offset', TType.I64, 2)
14033 
      oprot.writeI64(self.offset)
14034 
      oprot.writeFieldEnd()
14035 
    if self.limit is not None:
14036 
      oprot.writeFieldBegin('limit', TType.I64, 3)
14037 
      oprot.writeI64(self.limit)
14038 
      oprot.writeFieldEnd()
14039 
    oprot.writeFieldStop()
14040 
    oprot.writeStructEnd()
14041 
 
14042 
  def validate(self):
14043 
    return
14044 
 
14045 
 
14046 
  def __repr__(self):
14047 
    L = ['%s=%r' % (key, value)
14048 
      for key, value in self.__dict__.iteritems()]
14049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14050 
 
14051 
  def __eq__(self, other):
14052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14053 
 
14054 
  def __ne__(self, other):
14055 
    return not (self == other)
14056 
 
14057 
class searchItemsInRange_result:
14058 
  """
14059 
  Attributes:
14060 
   - success
14061 
  """
14062 
 
14063 
  thrift_spec = (
14064 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14065 
  )
14066 
 
14067 
  def __init__(self, success=None,):
14068 
    self.success = success
14069 
 
14070 
  def read(self, iprot):
14071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14073 
      return
14074 
    iprot.readStructBegin()
14075 
    while True:
14076 
      (fname, ftype, fid) = iprot.readFieldBegin()
14077 
      if ftype == TType.STOP:
14078 
        break
14079 
      if fid == 0:
14080 
        if ftype == TType.LIST:
14081 
          self.success = []
7438 amit.gupta 14082 
          (_etype261, _size258) = iprot.readListBegin()
14083 
          for _i262 in xrange(_size258):
14084 
            _elem263 = Item()
14085 
            _elem263.read(iprot)
14086 
            self.success.append(_elem263)
5944 mandeep.dh 14087 
          iprot.readListEnd()
14088 
        else:
14089 
          iprot.skip(ftype)
14090 
      else:
14091 
        iprot.skip(ftype)
14092 
      iprot.readFieldEnd()
14093 
    iprot.readStructEnd()
14094 
 
14095 
  def write(self, oprot):
14096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14098 
      return
14099 
    oprot.writeStructBegin('searchItemsInRange_result')
14100 
    if self.success is not None:
14101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14102 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14103 
      for iter264 in self.success:
14104 
        iter264.write(oprot)
5944 mandeep.dh 14105 
      oprot.writeListEnd()
14106 
      oprot.writeFieldEnd()
14107 
    oprot.writeFieldStop()
14108 
    oprot.writeStructEnd()
14109 
 
14110 
  def validate(self):
14111 
    return
14112 
 
14113 
 
14114 
  def __repr__(self):
14115 
    L = ['%s=%r' % (key, value)
14116 
      for key, value in self.__dict__.iteritems()]
14117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14118 
 
14119 
  def __eq__(self, other):
14120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14121 
 
14122 
  def __ne__(self, other):
14123 
    return not (self == other)
14124 
 
14125 
class getSearchResultCount_args:
14126 
  """
14127 
  Attributes:
14128 
   - searchTerms
14129 
  """
14130 
 
14131 
  thrift_spec = (
14132 
    None, # 0
14133 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14134 
  )
14135 
 
14136 
  def __init__(self, searchTerms=None,):
14137 
    self.searchTerms = searchTerms
14138 
 
14139 
  def read(self, iprot):
14140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14142 
      return
14143 
    iprot.readStructBegin()
14144 
    while True:
14145 
      (fname, ftype, fid) = iprot.readFieldBegin()
14146 
      if ftype == TType.STOP:
14147 
        break
14148 
      if fid == 1:
14149 
        if ftype == TType.LIST:
14150 
          self.searchTerms = []
7438 amit.gupta 14151 
          (_etype268, _size265) = iprot.readListBegin()
14152 
          for _i269 in xrange(_size265):
14153 
            _elem270 = iprot.readString();
14154 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14155 
          iprot.readListEnd()
14156 
        else:
14157 
          iprot.skip(ftype)
14158 
      else:
14159 
        iprot.skip(ftype)
14160 
      iprot.readFieldEnd()
14161 
    iprot.readStructEnd()
14162 
 
14163 
  def write(self, oprot):
14164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14166 
      return
14167 
    oprot.writeStructBegin('getSearchResultCount_args')
14168 
    if self.searchTerms is not None:
14169 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14170 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14171 
      for iter271 in self.searchTerms:
14172 
        oprot.writeString(iter271)
5944 mandeep.dh 14173 
      oprot.writeListEnd()
14174 
      oprot.writeFieldEnd()
14175 
    oprot.writeFieldStop()
14176 
    oprot.writeStructEnd()
14177 
 
14178 
  def validate(self):
14179 
    return
14180 
 
14181 
 
14182 
  def __repr__(self):
14183 
    L = ['%s=%r' % (key, value)
14184 
      for key, value in self.__dict__.iteritems()]
14185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14186 
 
14187 
  def __eq__(self, other):
14188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14189 
 
14190 
  def __ne__(self, other):
14191 
    return not (self == other)
14192 
 
14193 
class getSearchResultCount_result:
14194 
  """
14195 
  Attributes:
14196 
   - success
14197 
  """
14198 
 
14199 
  thrift_spec = (
14200 
    (0, TType.I32, 'success', None, None, ), # 0
14201 
  )
14202 
 
14203 
  def __init__(self, success=None,):
14204 
    self.success = success
14205 
 
14206 
  def read(self, iprot):
14207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14209 
      return
14210 
    iprot.readStructBegin()
14211 
    while True:
14212 
      (fname, ftype, fid) = iprot.readFieldBegin()
14213 
      if ftype == TType.STOP:
14214 
        break
14215 
      if fid == 0:
14216 
        if ftype == TType.I32:
14217 
          self.success = iprot.readI32();
14218 
        else:
14219 
          iprot.skip(ftype)
14220 
      else:
14221 
        iprot.skip(ftype)
14222 
      iprot.readFieldEnd()
14223 
    iprot.readStructEnd()
14224 
 
14225 
  def write(self, oprot):
14226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14228 
      return
14229 
    oprot.writeStructBegin('getSearchResultCount_result')
14230 
    if self.success is not None:
14231 
      oprot.writeFieldBegin('success', TType.I32, 0)
14232 
      oprot.writeI32(self.success)
14233 
      oprot.writeFieldEnd()
14234 
    oprot.writeFieldStop()
14235 
    oprot.writeStructEnd()
14236 
 
14237 
  def validate(self):
14238 
    return
14239 
 
14240 
 
14241 
  def __repr__(self):
14242 
    L = ['%s=%r' % (key, value)
14243 
      for key, value in self.__dict__.iteritems()]
14244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14245 
 
14246 
  def __eq__(self, other):
14247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14248 
 
14249 
  def __ne__(self, other):
14250 
    return not (self == other)
14251 
 
14252 
class getProductNotifications_args:
14253 
  """
14254 
  Attributes:
14255 
   - startDateTime
14256 
  """
14257 
 
14258 
  thrift_spec = (
14259 
    None, # 0
14260 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14261 
  )
14262 
 
14263 
  def __init__(self, startDateTime=None,):
14264 
    self.startDateTime = startDateTime
14265 
 
14266 
  def read(self, iprot):
14267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14269 
      return
14270 
    iprot.readStructBegin()
14271 
    while True:
14272 
      (fname, ftype, fid) = iprot.readFieldBegin()
14273 
      if ftype == TType.STOP:
14274 
        break
14275 
      if fid == 1:
14276 
        if ftype == TType.I64:
14277 
          self.startDateTime = iprot.readI64();
14278 
        else:
14279 
          iprot.skip(ftype)
14280 
      else:
14281 
        iprot.skip(ftype)
14282 
      iprot.readFieldEnd()
14283 
    iprot.readStructEnd()
14284 
 
14285 
  def write(self, oprot):
14286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14288 
      return
14289 
    oprot.writeStructBegin('getProductNotifications_args')
14290 
    if self.startDateTime is not None:
14291 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14292 
      oprot.writeI64(self.startDateTime)
14293 
      oprot.writeFieldEnd()
14294 
    oprot.writeFieldStop()
14295 
    oprot.writeStructEnd()
14296 
 
14297 
  def validate(self):
14298 
    return
14299 
 
14300 
 
14301 
  def __repr__(self):
14302 
    L = ['%s=%r' % (key, value)
14303 
      for key, value in self.__dict__.iteritems()]
14304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14305 
 
14306 
  def __eq__(self, other):
14307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14308 
 
14309 
  def __ne__(self, other):
14310 
    return not (self == other)
14311 
 
14312 
class getProductNotifications_result:
14313 
  """
14314 
  Attributes:
14315 
   - success
14316 
  """
14317 
 
14318 
  thrift_spec = (
14319 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14320 
  )
14321 
 
14322 
  def __init__(self, success=None,):
14323 
    self.success = success
14324 
 
14325 
  def read(self, iprot):
14326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14328 
      return
14329 
    iprot.readStructBegin()
14330 
    while True:
14331 
      (fname, ftype, fid) = iprot.readFieldBegin()
14332 
      if ftype == TType.STOP:
14333 
        break
14334 
      if fid == 0:
14335 
        if ftype == TType.LIST:
14336 
          self.success = []
7438 amit.gupta 14337 
          (_etype275, _size272) = iprot.readListBegin()
14338 
          for _i276 in xrange(_size272):
14339 
            _elem277 = ProductNotificationRequest()
14340 
            _elem277.read(iprot)
14341 
            self.success.append(_elem277)
5944 mandeep.dh 14342 
          iprot.readListEnd()
14343 
        else:
14344 
          iprot.skip(ftype)
14345 
      else:
14346 
        iprot.skip(ftype)
14347 
      iprot.readFieldEnd()
14348 
    iprot.readStructEnd()
14349 
 
14350 
  def write(self, oprot):
14351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14353 
      return
14354 
    oprot.writeStructBegin('getProductNotifications_result')
14355 
    if self.success is not None:
14356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14358 
      for iter278 in self.success:
14359 
        iter278.write(oprot)
5944 mandeep.dh 14360 
      oprot.writeListEnd()
14361 
      oprot.writeFieldEnd()
14362 
    oprot.writeFieldStop()
14363 
    oprot.writeStructEnd()
14364 
 
14365 
  def validate(self):
14366 
    return
14367 
 
14368 
 
14369 
  def __repr__(self):
14370 
    L = ['%s=%r' % (key, value)
14371 
      for key, value in self.__dict__.iteritems()]
14372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14373 
 
14374 
  def __eq__(self, other):
14375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14376 
 
14377 
  def __ne__(self, other):
14378 
    return not (self == other)
14379 
 
14380 
class getProductNotificationRequestCount_args:
14381 
  """
14382 
  Attributes:
14383 
   - startDateTime
7897 amar.kumar 14384 
   - categoryId
5944 mandeep.dh 14385 
  """
14386 
 
14387 
  thrift_spec = (
14388 
    None, # 0
14389 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 14390 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 14391 
  )
14392 
 
7897 amar.kumar 14393 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 14394 
    self.startDateTime = startDateTime
7897 amar.kumar 14395 
    self.categoryId = categoryId
5944 mandeep.dh 14396 
 
14397 
  def read(self, iprot):
14398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14400 
      return
14401 
    iprot.readStructBegin()
14402 
    while True:
14403 
      (fname, ftype, fid) = iprot.readFieldBegin()
14404 
      if ftype == TType.STOP:
14405 
        break
14406 
      if fid == 1:
14407 
        if ftype == TType.I64:
14408 
          self.startDateTime = iprot.readI64();
14409 
        else:
14410 
          iprot.skip(ftype)
7897 amar.kumar 14411 
      elif fid == 2:
14412 
        if ftype == TType.I64:
14413 
          self.categoryId = iprot.readI64();
14414 
        else:
14415 
          iprot.skip(ftype)
5944 mandeep.dh 14416 
      else:
14417 
        iprot.skip(ftype)
14418 
      iprot.readFieldEnd()
14419 
    iprot.readStructEnd()
14420 
 
14421 
  def write(self, oprot):
14422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14424 
      return
14425 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14426 
    if self.startDateTime is not None:
14427 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14428 
      oprot.writeI64(self.startDateTime)
14429 
      oprot.writeFieldEnd()
7897 amar.kumar 14430 
    if self.categoryId is not None:
14431 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
14432 
      oprot.writeI64(self.categoryId)
14433 
      oprot.writeFieldEnd()
5944 mandeep.dh 14434 
    oprot.writeFieldStop()
14435 
    oprot.writeStructEnd()
14436 
 
14437 
  def validate(self):
14438 
    return
14439 
 
14440 
 
14441 
  def __repr__(self):
14442 
    L = ['%s=%r' % (key, value)
14443 
      for key, value in self.__dict__.iteritems()]
14444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14445 
 
14446 
  def __eq__(self, other):
14447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14448 
 
14449 
  def __ne__(self, other):
14450 
    return not (self == other)
14451 
 
14452 
class getProductNotificationRequestCount_result:
14453 
  """
14454 
  Attributes:
14455 
   - success
14456 
  """
14457 
 
14458 
  thrift_spec = (
14459 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14460 
  )
14461 
 
14462 
  def __init__(self, success=None,):
14463 
    self.success = success
14464 
 
14465 
  def read(self, iprot):
14466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14468 
      return
14469 
    iprot.readStructBegin()
14470 
    while True:
14471 
      (fname, ftype, fid) = iprot.readFieldBegin()
14472 
      if ftype == TType.STOP:
14473 
        break
14474 
      if fid == 0:
14475 
        if ftype == TType.LIST:
14476 
          self.success = []
7438 amit.gupta 14477 
          (_etype282, _size279) = iprot.readListBegin()
14478 
          for _i283 in xrange(_size279):
14479 
            _elem284 = ProductNotificationRequestCount()
14480 
            _elem284.read(iprot)
14481 
            self.success.append(_elem284)
5944 mandeep.dh 14482 
          iprot.readListEnd()
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      else:
14486 
        iprot.skip(ftype)
14487 
      iprot.readFieldEnd()
14488 
    iprot.readStructEnd()
14489 
 
14490 
  def write(self, oprot):
14491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14493 
      return
14494 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14495 
    if self.success is not None:
14496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14498 
      for iter285 in self.success:
14499 
        iter285.write(oprot)
5944 mandeep.dh 14500 
      oprot.writeListEnd()
14501 
      oprot.writeFieldEnd()
14502 
    oprot.writeFieldStop()
14503 
    oprot.writeStructEnd()
14504 
 
14505 
  def validate(self):
14506 
    return
14507 
 
14508 
 
14509 
  def __repr__(self):
14510 
    L = ['%s=%r' % (key, value)
14511 
      for key, value in self.__dict__.iteritems()]
14512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14513 
 
14514 
  def __eq__(self, other):
14515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14516 
 
14517 
  def __ne__(self, other):
14518 
    return not (self == other)
14519 
 
14520 
class addAuthorizationLog_args:
14521 
  """
14522 
  Attributes:
14523 
   - itemId
14524 
   - username
14525 
   - reason
14526 
  """
14527 
 
14528 
  thrift_spec = (
14529 
    None, # 0
14530 
    (1, TType.I64, 'itemId', None, None, ), # 1
14531 
    (2, TType.STRING, 'username', None, None, ), # 2
14532 
    (3, TType.STRING, 'reason', None, None, ), # 3
14533 
  )
14534 
 
14535 
  def __init__(self, itemId=None, username=None, reason=None,):
14536 
    self.itemId = itemId
14537 
    self.username = username
14538 
    self.reason = reason
14539 
 
14540 
  def read(self, iprot):
14541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14543 
      return
14544 
    iprot.readStructBegin()
14545 
    while True:
14546 
      (fname, ftype, fid) = iprot.readFieldBegin()
14547 
      if ftype == TType.STOP:
14548 
        break
14549 
      if fid == 1:
14550 
        if ftype == TType.I64:
14551 
          self.itemId = iprot.readI64();
14552 
        else:
14553 
          iprot.skip(ftype)
14554 
      elif fid == 2:
14555 
        if ftype == TType.STRING:
14556 
          self.username = iprot.readString();
14557 
        else:
14558 
          iprot.skip(ftype)
14559 
      elif fid == 3:
14560 
        if ftype == TType.STRING:
14561 
          self.reason = iprot.readString();
14562 
        else:
14563 
          iprot.skip(ftype)
14564 
      else:
14565 
        iprot.skip(ftype)
14566 
      iprot.readFieldEnd()
14567 
    iprot.readStructEnd()
14568 
 
14569 
  def write(self, oprot):
14570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14572 
      return
14573 
    oprot.writeStructBegin('addAuthorizationLog_args')
14574 
    if self.itemId is not None:
14575 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14576 
      oprot.writeI64(self.itemId)
14577 
      oprot.writeFieldEnd()
14578 
    if self.username is not None:
14579 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14580 
      oprot.writeString(self.username)
14581 
      oprot.writeFieldEnd()
14582 
    if self.reason is not None:
14583 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14584 
      oprot.writeString(self.reason)
14585 
      oprot.writeFieldEnd()
14586 
    oprot.writeFieldStop()
14587 
    oprot.writeStructEnd()
14588 
 
14589 
  def validate(self):
14590 
    return
14591 
 
14592 
 
14593 
  def __repr__(self):
14594 
    L = ['%s=%r' % (key, value)
14595 
      for key, value in self.__dict__.iteritems()]
14596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14597 
 
14598 
  def __eq__(self, other):
14599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14600 
 
14601 
  def __ne__(self, other):
14602 
    return not (self == other)
14603 
 
14604 
class addAuthorizationLog_result:
14605 
  """
14606 
  Attributes:
14607 
   - success
14608 
   - cex
14609 
  """
14610 
 
14611 
  thrift_spec = (
14612 
    (0, TType.BOOL, 'success', None, None, ), # 0
14613 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14614 
  )
14615 
 
14616 
  def __init__(self, success=None, cex=None,):
14617 
    self.success = success
14618 
    self.cex = cex
14619 
 
14620 
  def read(self, iprot):
14621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14623 
      return
14624 
    iprot.readStructBegin()
14625 
    while True:
14626 
      (fname, ftype, fid) = iprot.readFieldBegin()
14627 
      if ftype == TType.STOP:
14628 
        break
14629 
      if fid == 0:
14630 
        if ftype == TType.BOOL:
14631 
          self.success = iprot.readBool();
14632 
        else:
14633 
          iprot.skip(ftype)
14634 
      elif fid == 1:
14635 
        if ftype == TType.STRUCT:
14636 
          self.cex = CatalogServiceException()
14637 
          self.cex.read(iprot)
14638 
        else:
14639 
          iprot.skip(ftype)
14640 
      else:
14641 
        iprot.skip(ftype)
14642 
      iprot.readFieldEnd()
14643 
    iprot.readStructEnd()
14644 
 
14645 
  def write(self, oprot):
14646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14648 
      return
14649 
    oprot.writeStructBegin('addAuthorizationLog_result')
14650 
    if self.success is not None:
14651 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14652 
      oprot.writeBool(self.success)
14653 
      oprot.writeFieldEnd()
14654 
    if self.cex is not None:
14655 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14656 
      self.cex.write(oprot)
14657 
      oprot.writeFieldEnd()
14658 
    oprot.writeFieldStop()
14659 
    oprot.writeStructEnd()
14660 
 
14661 
  def validate(self):
14662 
    return
14663 
 
14664 
 
14665 
  def __repr__(self):
14666 
    L = ['%s=%r' % (key, value)
14667 
      for key, value in self.__dict__.iteritems()]
14668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14669 
 
14670 
  def __eq__(self, other):
14671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14672 
 
14673 
  def __ne__(self, other):
14674 
    return not (self == other)
14675 
 
14676 
class addupdateVoucherForItem_args:
14677 
  """
14678 
  Attributes:
14679 
   - catalog_item_id
14680 
   - voucherType
14681 
   - voucherAmount
14682 
  """
14683 
 
14684 
  thrift_spec = (
14685 
    None, # 0
14686 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14687 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14688 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14689 
  )
14690 
 
14691 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14692 
    self.catalog_item_id = catalog_item_id
14693 
    self.voucherType = voucherType
14694 
    self.voucherAmount = voucherAmount
14695 
 
14696 
  def read(self, iprot):
14697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14699 
      return
14700 
    iprot.readStructBegin()
14701 
    while True:
14702 
      (fname, ftype, fid) = iprot.readFieldBegin()
14703 
      if ftype == TType.STOP:
14704 
        break
14705 
      if fid == 1:
14706 
        if ftype == TType.I64:
14707 
          self.catalog_item_id = iprot.readI64();
14708 
        else:
14709 
          iprot.skip(ftype)
14710 
      elif fid == 2:
14711 
        if ftype == TType.I64:
14712 
          self.voucherType = iprot.readI64();
14713 
        else:
14714 
          iprot.skip(ftype)
14715 
      elif fid == 3:
14716 
        if ftype == TType.I64:
14717 
          self.voucherAmount = iprot.readI64();
14718 
        else:
14719 
          iprot.skip(ftype)
14720 
      else:
14721 
        iprot.skip(ftype)
14722 
      iprot.readFieldEnd()
14723 
    iprot.readStructEnd()
14724 
 
14725 
  def write(self, oprot):
14726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14728 
      return
14729 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14730 
    if self.catalog_item_id is not None:
14731 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14732 
      oprot.writeI64(self.catalog_item_id)
14733 
      oprot.writeFieldEnd()
14734 
    if self.voucherType is not None:
14735 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14736 
      oprot.writeI64(self.voucherType)
14737 
      oprot.writeFieldEnd()
14738 
    if self.voucherAmount is not None:
14739 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14740 
      oprot.writeI64(self.voucherAmount)
14741 
      oprot.writeFieldEnd()
14742 
    oprot.writeFieldStop()
14743 
    oprot.writeStructEnd()
14744 
 
14745 
  def validate(self):
14746 
    return
14747 
 
14748 
 
14749 
  def __repr__(self):
14750 
    L = ['%s=%r' % (key, value)
14751 
      for key, value in self.__dict__.iteritems()]
14752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14753 
 
14754 
  def __eq__(self, other):
14755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14756 
 
14757 
  def __ne__(self, other):
14758 
    return not (self == other)
14759 
 
14760 
class addupdateVoucherForItem_result:
14761 
  """
14762 
  Attributes:
14763 
   - success
14764 
   - cex
14765 
  """
14766 
 
14767 
  thrift_spec = (
14768 
    (0, TType.BOOL, 'success', None, None, ), # 0
14769 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14770 
  )
14771 
 
14772 
  def __init__(self, success=None, cex=None,):
14773 
    self.success = success
14774 
    self.cex = cex
14775 
 
14776 
  def read(self, iprot):
14777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14779 
      return
14780 
    iprot.readStructBegin()
14781 
    while True:
14782 
      (fname, ftype, fid) = iprot.readFieldBegin()
14783 
      if ftype == TType.STOP:
14784 
        break
14785 
      if fid == 0:
14786 
        if ftype == TType.BOOL:
14787 
          self.success = iprot.readBool();
14788 
        else:
14789 
          iprot.skip(ftype)
14790 
      elif fid == 1:
14791 
        if ftype == TType.STRUCT:
14792 
          self.cex = CatalogServiceException()
14793 
          self.cex.read(iprot)
14794 
        else:
14795 
          iprot.skip(ftype)
14796 
      else:
14797 
        iprot.skip(ftype)
14798 
      iprot.readFieldEnd()
14799 
    iprot.readStructEnd()
14800 
 
14801 
  def write(self, oprot):
14802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14804 
      return
14805 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14806 
    if self.success is not None:
14807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14808 
      oprot.writeBool(self.success)
14809 
      oprot.writeFieldEnd()
14810 
    if self.cex is not None:
14811 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14812 
      self.cex.write(oprot)
14813 
      oprot.writeFieldEnd()
14814 
    oprot.writeFieldStop()
14815 
    oprot.writeStructEnd()
14816 
 
14817 
  def validate(self):
14818 
    return
14819 
 
14820 
 
14821 
  def __repr__(self):
14822 
    L = ['%s=%r' % (key, value)
14823 
      for key, value in self.__dict__.iteritems()]
14824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14825 
 
14826 
  def __eq__(self, other):
14827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14828 
 
14829 
  def __ne__(self, other):
14830 
    return not (self == other)
14831 
 
14832 
class deleteVoucherForItem_args:
14833 
  """
14834 
  Attributes:
14835 
   - catalog_item_id
14836 
   - voucherType
14837 
  """
14838 
 
14839 
  thrift_spec = (
14840 
    None, # 0
14841 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14842 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14843 
  )
14844 
 
14845 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14846 
    self.catalog_item_id = catalog_item_id
14847 
    self.voucherType = voucherType
14848 
 
14849 
  def read(self, iprot):
14850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14852 
      return
14853 
    iprot.readStructBegin()
14854 
    while True:
14855 
      (fname, ftype, fid) = iprot.readFieldBegin()
14856 
      if ftype == TType.STOP:
14857 
        break
14858 
      if fid == 1:
14859 
        if ftype == TType.I64:
14860 
          self.catalog_item_id = iprot.readI64();
14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      elif fid == 2:
14864 
        if ftype == TType.I64:
14865 
          self.voucherType = iprot.readI64();
14866 
        else:
14867 
          iprot.skip(ftype)
14868 
      else:
14869 
        iprot.skip(ftype)
14870 
      iprot.readFieldEnd()
14871 
    iprot.readStructEnd()
14872 
 
14873 
  def write(self, oprot):
14874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14876 
      return
14877 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14878 
    if self.catalog_item_id is not None:
14879 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14880 
      oprot.writeI64(self.catalog_item_id)
14881 
      oprot.writeFieldEnd()
14882 
    if self.voucherType is not None:
14883 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14884 
      oprot.writeI64(self.voucherType)
14885 
      oprot.writeFieldEnd()
14886 
    oprot.writeFieldStop()
14887 
    oprot.writeStructEnd()
14888 
 
14889 
  def validate(self):
14890 
    return
14891 
 
14892 
 
14893 
  def __repr__(self):
14894 
    L = ['%s=%r' % (key, value)
14895 
      for key, value in self.__dict__.iteritems()]
14896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14897 
 
14898 
  def __eq__(self, other):
14899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14900 
 
14901 
  def __ne__(self, other):
14902 
    return not (self == other)
14903 
 
14904 
class deleteVoucherForItem_result:
14905 
  """
14906 
  Attributes:
14907 
   - success
14908 
   - cex
14909 
  """
14910 
 
14911 
  thrift_spec = (
14912 
    (0, TType.BOOL, 'success', None, None, ), # 0
14913 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14914 
  )
14915 
 
14916 
  def __init__(self, success=None, cex=None,):
14917 
    self.success = success
14918 
    self.cex = cex
14919 
 
14920 
  def read(self, iprot):
14921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14923 
      return
14924 
    iprot.readStructBegin()
14925 
    while True:
14926 
      (fname, ftype, fid) = iprot.readFieldBegin()
14927 
      if ftype == TType.STOP:
14928 
        break
14929 
      if fid == 0:
14930 
        if ftype == TType.BOOL:
14931 
          self.success = iprot.readBool();
14932 
        else:
14933 
          iprot.skip(ftype)
14934 
      elif fid == 1:
14935 
        if ftype == TType.STRUCT:
14936 
          self.cex = CatalogServiceException()
14937 
          self.cex.read(iprot)
14938 
        else:
14939 
          iprot.skip(ftype)
14940 
      else:
14941 
        iprot.skip(ftype)
14942 
      iprot.readFieldEnd()
14943 
    iprot.readStructEnd()
14944 
 
14945 
  def write(self, oprot):
14946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14948 
      return
14949 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14950 
    if self.success is not None:
14951 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14952 
      oprot.writeBool(self.success)
14953 
      oprot.writeFieldEnd()
14954 
    if self.cex is not None:
14955 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14956 
      self.cex.write(oprot)
14957 
      oprot.writeFieldEnd()
14958 
    oprot.writeFieldStop()
14959 
    oprot.writeStructEnd()
14960 
 
14961 
  def validate(self):
14962 
    return
14963 
 
14964 
 
14965 
  def __repr__(self):
14966 
    L = ['%s=%r' % (key, value)
14967 
      for key, value in self.__dict__.iteritems()]
14968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14969 
 
14970 
  def __eq__(self, other):
14971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14972 
 
14973 
  def __ne__(self, other):
14974 
    return not (self == other)
14975 
 
14976 
class getVoucherAmount_args:
14977 
  """
14978 
  Attributes:
14979 
   - itemId
14980 
   - voucherType
14981 
  """
14982 
 
14983 
  thrift_spec = (
14984 
    None, # 0
14985 
    (1, TType.I64, 'itemId', None, None, ), # 1
14986 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14987 
  )
14988 
 
14989 
  def __init__(self, itemId=None, voucherType=None,):
14990 
    self.itemId = itemId
14991 
    self.voucherType = voucherType
14992 
 
14993 
  def read(self, iprot):
14994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14996 
      return
14997 
    iprot.readStructBegin()
14998 
    while True:
14999 
      (fname, ftype, fid) = iprot.readFieldBegin()
15000 
      if ftype == TType.STOP:
15001 
        break
15002 
      if fid == 1:
15003 
        if ftype == TType.I64:
15004 
          self.itemId = iprot.readI64();
15005 
        else:
15006 
          iprot.skip(ftype)
15007 
      elif fid == 2:
15008 
        if ftype == TType.I64:
15009 
          self.voucherType = iprot.readI64();
15010 
        else:
15011 
          iprot.skip(ftype)
15012 
      else:
15013 
        iprot.skip(ftype)
15014 
      iprot.readFieldEnd()
15015 
    iprot.readStructEnd()
15016 
 
15017 
  def write(self, oprot):
15018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15020 
      return
15021 
    oprot.writeStructBegin('getVoucherAmount_args')
15022 
    if self.itemId is not None:
15023 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15024 
      oprot.writeI64(self.itemId)
15025 
      oprot.writeFieldEnd()
15026 
    if self.voucherType is not None:
15027 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15028 
      oprot.writeI64(self.voucherType)
15029 
      oprot.writeFieldEnd()
15030 
    oprot.writeFieldStop()
15031 
    oprot.writeStructEnd()
15032 
 
15033 
  def validate(self):
15034 
    return
15035 
 
15036 
 
15037 
  def __repr__(self):
15038 
    L = ['%s=%r' % (key, value)
15039 
      for key, value in self.__dict__.iteritems()]
15040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15041 
 
15042 
  def __eq__(self, other):
15043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15044 
 
15045 
  def __ne__(self, other):
15046 
    return not (self == other)
15047 
 
15048 
class getVoucherAmount_result:
15049 
  """
15050 
  Attributes:
15051 
   - success
15052 
  """
15053 
 
15054 
  thrift_spec = (
15055 
    (0, TType.I64, 'success', None, None, ), # 0
15056 
  )
15057 
 
15058 
  def __init__(self, success=None,):
15059 
    self.success = success
15060 
 
15061 
  def read(self, iprot):
15062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15064 
      return
15065 
    iprot.readStructBegin()
15066 
    while True:
15067 
      (fname, ftype, fid) = iprot.readFieldBegin()
15068 
      if ftype == TType.STOP:
15069 
        break
15070 
      if fid == 0:
15071 
        if ftype == TType.I64:
15072 
          self.success = iprot.readI64();
15073 
        else:
15074 
          iprot.skip(ftype)
15075 
      else:
15076 
        iprot.skip(ftype)
15077 
      iprot.readFieldEnd()
15078 
    iprot.readStructEnd()
15079 
 
15080 
  def write(self, oprot):
15081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15083 
      return
15084 
    oprot.writeStructBegin('getVoucherAmount_result')
15085 
    if self.success is not None:
15086 
      oprot.writeFieldBegin('success', TType.I64, 0)
15087 
      oprot.writeI64(self.success)
15088 
      oprot.writeFieldEnd()
15089 
    oprot.writeFieldStop()
15090 
    oprot.writeStructEnd()
15091 
 
15092 
  def validate(self):
15093 
    return
15094 
 
15095 
 
15096 
  def __repr__(self):
15097 
    L = ['%s=%r' % (key, value)
15098 
      for key, value in self.__dict__.iteritems()]
15099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15100 
 
15101 
  def __eq__(self, other):
15102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15103 
 
15104 
  def __ne__(self, other):
15105 
    return not (self == other)
15106 
 
15107 
class getAllItemVouchers_args:
15108 
  """
15109 
  Attributes:
15110 
   - itemId
15111 
  """
15112 
 
15113 
  thrift_spec = (
15114 
    None, # 0
15115 
    (1, TType.I64, 'itemId', None, None, ), # 1
15116 
  )
15117 
 
15118 
  def __init__(self, itemId=None,):
15119 
    self.itemId = itemId
15120 
 
15121 
  def read(self, iprot):
15122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15124 
      return
15125 
    iprot.readStructBegin()
15126 
    while True:
15127 
      (fname, ftype, fid) = iprot.readFieldBegin()
15128 
      if ftype == TType.STOP:
15129 
        break
15130 
      if fid == 1:
15131 
        if ftype == TType.I64:
15132 
          self.itemId = iprot.readI64();
15133 
        else:
15134 
          iprot.skip(ftype)
15135 
      else:
15136 
        iprot.skip(ftype)
15137 
      iprot.readFieldEnd()
15138 
    iprot.readStructEnd()
15139 
 
15140 
  def write(self, oprot):
15141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15143 
      return
15144 
    oprot.writeStructBegin('getAllItemVouchers_args')
15145 
    if self.itemId is not None:
15146 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15147 
      oprot.writeI64(self.itemId)
15148 
      oprot.writeFieldEnd()
15149 
    oprot.writeFieldStop()
15150 
    oprot.writeStructEnd()
15151 
 
15152 
  def validate(self):
15153 
    return
15154 
 
15155 
 
15156 
  def __repr__(self):
15157 
    L = ['%s=%r' % (key, value)
15158 
      for key, value in self.__dict__.iteritems()]
15159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15160 
 
15161 
  def __eq__(self, other):
15162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15163 
 
15164 
  def __ne__(self, other):
15165 
    return not (self == other)
15166 
 
15167 
class getAllItemVouchers_result:
15168 
  """
15169 
  Attributes:
15170 
   - success
15171 
  """
15172 
 
15173 
  thrift_spec = (
15174 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15175 
  )
15176 
 
15177 
  def __init__(self, success=None,):
15178 
    self.success = success
15179 
 
15180 
  def read(self, iprot):
15181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15183 
      return
15184 
    iprot.readStructBegin()
15185 
    while True:
15186 
      (fname, ftype, fid) = iprot.readFieldBegin()
15187 
      if ftype == TType.STOP:
15188 
        break
15189 
      if fid == 0:
15190 
        if ftype == TType.LIST:
15191 
          self.success = []
7438 amit.gupta 15192 
          (_etype289, _size286) = iprot.readListBegin()
15193 
          for _i290 in xrange(_size286):
15194 
            _elem291 = VoucherItemMapping()
15195 
            _elem291.read(iprot)
15196 
            self.success.append(_elem291)
5944 mandeep.dh 15197 
          iprot.readListEnd()
15198 
        else:
15199 
          iprot.skip(ftype)
15200 
      else:
15201 
        iprot.skip(ftype)
15202 
      iprot.readFieldEnd()
15203 
    iprot.readStructEnd()
15204 
 
15205 
  def write(self, oprot):
15206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15208 
      return
15209 
    oprot.writeStructBegin('getAllItemVouchers_result')
15210 
    if self.success is not None:
15211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15212 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15213 
      for iter292 in self.success:
15214 
        iter292.write(oprot)
5944 mandeep.dh 15215 
      oprot.writeListEnd()
15216 
      oprot.writeFieldEnd()
15217 
    oprot.writeFieldStop()
15218 
    oprot.writeStructEnd()
15219 
 
15220 
  def validate(self):
15221 
    return
15222 
 
15223 
 
15224 
  def __repr__(self):
15225 
    L = ['%s=%r' % (key, value)
15226 
      for key, value in self.__dict__.iteritems()]
15227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15228 
 
15229 
  def __eq__(self, other):
15230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15231 
 
15232 
  def __ne__(self, other):
15233 
    return not (self == other)
15234 
 
15235 
class isValidCatalogItemId_args:
15236 
  """
15237 
  Attributes:
15238 
   - catalog_item_id
15239 
  """
15240 
 
15241 
  thrift_spec = (
15242 
    None, # 0
15243 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15244 
  )
15245 
 
15246 
  def __init__(self, catalog_item_id=None,):
15247 
    self.catalog_item_id = catalog_item_id
15248 
 
15249 
  def read(self, iprot):
15250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15252 
      return
15253 
    iprot.readStructBegin()
15254 
    while True:
15255 
      (fname, ftype, fid) = iprot.readFieldBegin()
15256 
      if ftype == TType.STOP:
15257 
        break
15258 
      if fid == 1:
15259 
        if ftype == TType.I64:
15260 
          self.catalog_item_id = iprot.readI64();
15261 
        else:
15262 
          iprot.skip(ftype)
15263 
      else:
15264 
        iprot.skip(ftype)
15265 
      iprot.readFieldEnd()
15266 
    iprot.readStructEnd()
15267 
 
15268 
  def write(self, oprot):
15269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15271 
      return
15272 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15273 
    if self.catalog_item_id is not None:
15274 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15275 
      oprot.writeI64(self.catalog_item_id)
15276 
      oprot.writeFieldEnd()
15277 
    oprot.writeFieldStop()
15278 
    oprot.writeStructEnd()
15279 
 
15280 
  def validate(self):
15281 
    return
15282 
 
15283 
 
15284 
  def __repr__(self):
15285 
    L = ['%s=%r' % (key, value)
15286 
      for key, value in self.__dict__.iteritems()]
15287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15288 
 
15289 
  def __eq__(self, other):
15290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15291 
 
15292 
  def __ne__(self, other):
15293 
    return not (self == other)
15294 
 
15295 
class isValidCatalogItemId_result:
15296 
  """
15297 
  Attributes:
15298 
   - success
15299 
  """
15300 
 
15301 
  thrift_spec = (
15302 
    (0, TType.BOOL, 'success', None, None, ), # 0
15303 
  )
15304 
 
15305 
  def __init__(self, success=None,):
15306 
    self.success = success
15307 
 
15308 
  def read(self, iprot):
15309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15311 
      return
15312 
    iprot.readStructBegin()
15313 
    while True:
15314 
      (fname, ftype, fid) = iprot.readFieldBegin()
15315 
      if ftype == TType.STOP:
15316 
        break
15317 
      if fid == 0:
15318 
        if ftype == TType.BOOL:
15319 
          self.success = iprot.readBool();
15320 
        else:
15321 
          iprot.skip(ftype)
15322 
      else:
15323 
        iprot.skip(ftype)
15324 
      iprot.readFieldEnd()
15325 
    iprot.readStructEnd()
15326 
 
15327 
  def write(self, oprot):
15328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15330 
      return
15331 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15332 
    if self.success is not None:
15333 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15334 
      oprot.writeBool(self.success)
15335 
      oprot.writeFieldEnd()
15336 
    oprot.writeFieldStop()
15337 
    oprot.writeStructEnd()
15338 
 
15339 
  def validate(self):
15340 
    return
15341 
 
15342 
 
15343 
  def __repr__(self):
15344 
    L = ['%s=%r' % (key, value)
15345 
      for key, value in self.__dict__.iteritems()]
15346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15347 
 
15348 
  def __eq__(self, other):
15349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15350 
 
15351 
  def __ne__(self, other):
15352 
    return not (self == other)
6039 amit.gupta 15353 
 
15354 
class getVatPercentageForItem_args:
15355 
  """
15356 
  Attributes:
15357 
   - itemId
7330 amit.gupta 15358 
   - stateId
6039 amit.gupta 15359 
   - price
15360 
  """
15361 
 
15362 
  thrift_spec = (
15363 
    None, # 0
15364 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15365 
    (2, TType.I64, 'stateId', None, None, ), # 2
15366 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15367 
  )
15368 
 
7330 amit.gupta 15369 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15370 
    self.itemId = itemId
7330 amit.gupta 15371 
    self.stateId = stateId
6039 amit.gupta 15372 
    self.price = price
15373 
 
15374 
  def read(self, iprot):
15375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15377 
      return
15378 
    iprot.readStructBegin()
15379 
    while True:
15380 
      (fname, ftype, fid) = iprot.readFieldBegin()
15381 
      if ftype == TType.STOP:
15382 
        break
15383 
      if fid == 1:
15384 
        if ftype == TType.I64:
15385 
          self.itemId = iprot.readI64();
15386 
        else:
15387 
          iprot.skip(ftype)
15388 
      elif fid == 2:
7330 amit.gupta 15389 
        if ftype == TType.I64:
15390 
          self.stateId = iprot.readI64();
15391 
        else:
15392 
          iprot.skip(ftype)
15393 
      elif fid == 3:
6039 amit.gupta 15394 
        if ftype == TType.DOUBLE:
15395 
          self.price = iprot.readDouble();
15396 
        else:
15397 
          iprot.skip(ftype)
15398 
      else:
15399 
        iprot.skip(ftype)
15400 
      iprot.readFieldEnd()
15401 
    iprot.readStructEnd()
15402 
 
15403 
  def write(self, oprot):
15404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15406 
      return
15407 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15408 
    if self.itemId is not None:
15409 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15410 
      oprot.writeI64(self.itemId)
15411 
      oprot.writeFieldEnd()
7330 amit.gupta 15412 
    if self.stateId is not None:
15413 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15414 
      oprot.writeI64(self.stateId)
15415 
      oprot.writeFieldEnd()
6039 amit.gupta 15416 
    if self.price is not None:
7330 amit.gupta 15417 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15418 
      oprot.writeDouble(self.price)
15419 
      oprot.writeFieldEnd()
15420 
    oprot.writeFieldStop()
15421 
    oprot.writeStructEnd()
15422 
 
15423 
  def validate(self):
15424 
    return
15425 
 
15426 
 
15427 
  def __repr__(self):
15428 
    L = ['%s=%r' % (key, value)
15429 
      for key, value in self.__dict__.iteritems()]
15430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15431 
 
15432 
  def __eq__(self, other):
15433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15434 
 
15435 
  def __ne__(self, other):
15436 
    return not (self == other)
15437 
 
15438 
class getVatPercentageForItem_result:
15439 
  """
15440 
  Attributes:
15441 
   - success
7340 amit.gupta 15442 
   - cex
6039 amit.gupta 15443 
  """
15444 
 
15445 
  thrift_spec = (
15446 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15447 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15448 
  )
15449 
 
7340 amit.gupta 15450 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15451 
    self.success = success
7340 amit.gupta 15452 
    self.cex = cex
6039 amit.gupta 15453 
 
15454 
  def read(self, iprot):
15455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15457 
      return
15458 
    iprot.readStructBegin()
15459 
    while True:
15460 
      (fname, ftype, fid) = iprot.readFieldBegin()
15461 
      if ftype == TType.STOP:
15462 
        break
15463 
      if fid == 0:
15464 
        if ftype == TType.DOUBLE:
15465 
          self.success = iprot.readDouble();
15466 
        else:
15467 
          iprot.skip(ftype)
7340 amit.gupta 15468 
      elif fid == 1:
15469 
        if ftype == TType.STRUCT:
15470 
          self.cex = CatalogServiceException()
15471 
          self.cex.read(iprot)
15472 
        else:
15473 
          iprot.skip(ftype)
6039 amit.gupta 15474 
      else:
15475 
        iprot.skip(ftype)
15476 
      iprot.readFieldEnd()
15477 
    iprot.readStructEnd()
15478 
 
15479 
  def write(self, oprot):
15480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15482 
      return
15483 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15484 
    if self.success is not None:
15485 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15486 
      oprot.writeDouble(self.success)
15487 
      oprot.writeFieldEnd()
7340 amit.gupta 15488 
    if self.cex is not None:
15489 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15490 
      self.cex.write(oprot)
15491 
      oprot.writeFieldEnd()
6039 amit.gupta 15492 
    oprot.writeFieldStop()
15493 
    oprot.writeStructEnd()
15494 
 
15495 
  def validate(self):
15496 
    return
15497 
 
15498 
 
15499 
  def __repr__(self):
15500 
    L = ['%s=%r' % (key, value)
15501 
      for key, value in self.__dict__.iteritems()]
15502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15503 
 
15504 
  def __eq__(self, other):
15505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15506 
 
15507 
  def __ne__(self, other):
15508 
    return not (self == other)
15509 
 
15510 
class getVatAmountForItem_args:
15511 
  """
15512 
  Attributes:
15513 
   - itemId
15514 
   - price
15515 
  """
15516 
 
15517 
  thrift_spec = (
15518 
    None, # 0
15519 
    (1, TType.I64, 'itemId', None, None, ), # 1
15520 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15521 
  )
15522 
 
15523 
  def __init__(self, itemId=None, price=None,):
15524 
    self.itemId = itemId
15525 
    self.price = price
15526 
 
15527 
  def read(self, iprot):
15528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15530 
      return
15531 
    iprot.readStructBegin()
15532 
    while True:
15533 
      (fname, ftype, fid) = iprot.readFieldBegin()
15534 
      if ftype == TType.STOP:
15535 
        break
15536 
      if fid == 1:
15537 
        if ftype == TType.I64:
15538 
          self.itemId = iprot.readI64();
15539 
        else:
15540 
          iprot.skip(ftype)
15541 
      elif fid == 2:
15542 
        if ftype == TType.DOUBLE:
15543 
          self.price = iprot.readDouble();
15544 
        else:
15545 
          iprot.skip(ftype)
15546 
      else:
15547 
        iprot.skip(ftype)
15548 
      iprot.readFieldEnd()
15549 
    iprot.readStructEnd()
15550 
 
15551 
  def write(self, oprot):
15552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15554 
      return
15555 
    oprot.writeStructBegin('getVatAmountForItem_args')
15556 
    if self.itemId is not None:
15557 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15558 
      oprot.writeI64(self.itemId)
15559 
      oprot.writeFieldEnd()
15560 
    if self.price is not None:
15561 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15562 
      oprot.writeDouble(self.price)
15563 
      oprot.writeFieldEnd()
15564 
    oprot.writeFieldStop()
15565 
    oprot.writeStructEnd()
15566 
 
15567 
  def validate(self):
15568 
    return
15569 
 
15570 
 
15571 
  def __repr__(self):
15572 
    L = ['%s=%r' % (key, value)
15573 
      for key, value in self.__dict__.iteritems()]
15574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15575 
 
15576 
  def __eq__(self, other):
15577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15578 
 
15579 
  def __ne__(self, other):
15580 
    return not (self == other)
15581 
 
15582 
class getVatAmountForItem_result:
15583 
  """
15584 
  Attributes:
15585 
   - success
15586 
  """
15587 
 
15588 
  thrift_spec = (
15589 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15590 
  )
15591 
 
15592 
  def __init__(self, success=None,):
15593 
    self.success = success
15594 
 
15595 
  def read(self, iprot):
15596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15598 
      return
15599 
    iprot.readStructBegin()
15600 
    while True:
15601 
      (fname, ftype, fid) = iprot.readFieldBegin()
15602 
      if ftype == TType.STOP:
15603 
        break
15604 
      if fid == 0:
15605 
        if ftype == TType.DOUBLE:
15606 
          self.success = iprot.readDouble();
15607 
        else:
15608 
          iprot.skip(ftype)
15609 
      else:
15610 
        iprot.skip(ftype)
15611 
      iprot.readFieldEnd()
15612 
    iprot.readStructEnd()
15613 
 
15614 
  def write(self, oprot):
15615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15617 
      return
15618 
    oprot.writeStructBegin('getVatAmountForItem_result')
15619 
    if self.success is not None:
15620 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15621 
      oprot.writeDouble(self.success)
15622 
      oprot.writeFieldEnd()
15623 
    oprot.writeFieldStop()
15624 
    oprot.writeStructEnd()
15625 
 
15626 
  def validate(self):
15627 
    return
15628 
 
15629 
 
15630 
  def __repr__(self):
15631 
    L = ['%s=%r' % (key, value)
15632 
      for key, value in self.__dict__.iteritems()]
15633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15634 
 
15635 
  def __eq__(self, other):
15636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15637 
 
15638 
  def __ne__(self, other):
15639 
    return not (self == other)
6531 vikram.rag 15640 
 
15641 
class getAllIgnoredInventoryUpdateItemsList_args:
15642 
  """
15643 
  Attributes:
15644 
   - offset
15645 
   - limit
15646 
  """
15647 
 
15648 
  thrift_spec = (
15649 
    None, # 0
15650 
    (1, TType.I32, 'offset', None, None, ), # 1
15651 
    (2, TType.I32, 'limit', None, None, ), # 2
15652 
  )
15653 
 
15654 
  def __init__(self, offset=None, limit=None,):
15655 
    self.offset = offset
15656 
    self.limit = limit
15657 
 
15658 
  def read(self, iprot):
15659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15661 
      return
15662 
    iprot.readStructBegin()
15663 
    while True:
15664 
      (fname, ftype, fid) = iprot.readFieldBegin()
15665 
      if ftype == TType.STOP:
15666 
        break
15667 
      if fid == 1:
15668 
        if ftype == TType.I32:
15669 
          self.offset = iprot.readI32();
15670 
        else:
15671 
          iprot.skip(ftype)
15672 
      elif fid == 2:
15673 
        if ftype == TType.I32:
15674 
          self.limit = iprot.readI32();
15675 
        else:
15676 
          iprot.skip(ftype)
15677 
      else:
15678 
        iprot.skip(ftype)
15679 
      iprot.readFieldEnd()
15680 
    iprot.readStructEnd()
15681 
 
15682 
  def write(self, oprot):
15683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15685 
      return
15686 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15687 
    if self.offset is not None:
15688 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15689 
      oprot.writeI32(self.offset)
15690 
      oprot.writeFieldEnd()
15691 
    if self.limit is not None:
15692 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15693 
      oprot.writeI32(self.limit)
15694 
      oprot.writeFieldEnd()
15695 
    oprot.writeFieldStop()
15696 
    oprot.writeStructEnd()
15697 
 
15698 
  def validate(self):
15699 
    return
15700 
 
15701 
 
15702 
  def __repr__(self):
15703 
    L = ['%s=%r' % (key, value)
15704 
      for key, value in self.__dict__.iteritems()]
15705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15706 
 
15707 
  def __eq__(self, other):
15708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15709 
 
15710 
  def __ne__(self, other):
15711 
    return not (self == other)
15712 
 
15713 
class getAllIgnoredInventoryUpdateItemsList_result:
15714 
  """
15715 
  Attributes:
15716 
   - success
15717 
  """
15718 
 
15719 
  thrift_spec = (
15720 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15721 
  )
15722 
 
15723 
  def __init__(self, success=None,):
15724 
    self.success = success
15725 
 
15726 
  def read(self, iprot):
15727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15729 
      return
15730 
    iprot.readStructBegin()
15731 
    while True:
15732 
      (fname, ftype, fid) = iprot.readFieldBegin()
15733 
      if ftype == TType.STOP:
15734 
        break
15735 
      if fid == 0:
15736 
        if ftype == TType.LIST:
15737 
          self.success = []
7438 amit.gupta 15738 
          (_etype296, _size293) = iprot.readListBegin()
15739 
          for _i297 in xrange(_size293):
15740 
            _elem298 = Item()
15741 
            _elem298.read(iprot)
15742 
            self.success.append(_elem298)
6531 vikram.rag 15743 
          iprot.readListEnd()
15744 
        else:
15745 
          iprot.skip(ftype)
15746 
      else:
15747 
        iprot.skip(ftype)
15748 
      iprot.readFieldEnd()
15749 
    iprot.readStructEnd()
15750 
 
15751 
  def write(self, oprot):
15752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15754 
      return
15755 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15756 
    if self.success is not None:
15757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15759 
      for iter299 in self.success:
15760 
        iter299.write(oprot)
6531 vikram.rag 15761 
      oprot.writeListEnd()
15762 
      oprot.writeFieldEnd()
15763 
    oprot.writeFieldStop()
15764 
    oprot.writeStructEnd()
15765 
 
15766 
  def validate(self):
15767 
    return
15768 
 
15769 
 
15770 
  def __repr__(self):
15771 
    L = ['%s=%r' % (key, value)
15772 
      for key, value in self.__dict__.iteritems()]
15773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15774 
 
15775 
  def __eq__(self, other):
15776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15777 
 
15778 
  def __ne__(self, other):
15779 
    return not (self == other)
6805 anupam.sin 15780 
 
6821 amar.kumar 15781 
class getAllAliveItems_args:
15782 
 
15783 
  thrift_spec = (
15784 
  )
15785 
 
15786 
  def read(self, iprot):
15787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15789 
      return
15790 
    iprot.readStructBegin()
15791 
    while True:
15792 
      (fname, ftype, fid) = iprot.readFieldBegin()
15793 
      if ftype == TType.STOP:
15794 
        break
15795 
      else:
15796 
        iprot.skip(ftype)
15797 
      iprot.readFieldEnd()
15798 
    iprot.readStructEnd()
15799 
 
15800 
  def write(self, oprot):
15801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15803 
      return
15804 
    oprot.writeStructBegin('getAllAliveItems_args')
15805 
    oprot.writeFieldStop()
15806 
    oprot.writeStructEnd()
15807 
 
15808 
  def validate(self):
15809 
    return
15810 
 
15811 
 
15812 
  def __repr__(self):
15813 
    L = ['%s=%r' % (key, value)
15814 
      for key, value in self.__dict__.iteritems()]
15815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15816 
 
15817 
  def __eq__(self, other):
15818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15819 
 
15820 
  def __ne__(self, other):
15821 
    return not (self == other)
15822 
 
15823 
class getAllAliveItems_result:
15824 
  """
15825 
  Attributes:
15826 
   - success
15827 
  """
15828 
 
15829 
  thrift_spec = (
15830 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15831 
  )
15832 
 
15833 
  def __init__(self, success=None,):
15834 
    self.success = success
15835 
 
15836 
  def read(self, iprot):
15837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15839 
      return
15840 
    iprot.readStructBegin()
15841 
    while True:
15842 
      (fname, ftype, fid) = iprot.readFieldBegin()
15843 
      if ftype == TType.STOP:
15844 
        break
15845 
      if fid == 0:
15846 
        if ftype == TType.LIST:
15847 
          self.success = []
7438 amit.gupta 15848 
          (_etype303, _size300) = iprot.readListBegin()
15849 
          for _i304 in xrange(_size300):
15850 
            _elem305 = Item()
15851 
            _elem305.read(iprot)
15852 
            self.success.append(_elem305)
6821 amar.kumar 15853 
          iprot.readListEnd()
15854 
        else:
15855 
          iprot.skip(ftype)
15856 
      else:
15857 
        iprot.skip(ftype)
15858 
      iprot.readFieldEnd()
15859 
    iprot.readStructEnd()
15860 
 
15861 
  def write(self, oprot):
15862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15864 
      return
15865 
    oprot.writeStructBegin('getAllAliveItems_result')
15866 
    if self.success is not None:
15867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15869 
      for iter306 in self.success:
15870 
        iter306.write(oprot)
6821 amar.kumar 15871 
      oprot.writeListEnd()
15872 
      oprot.writeFieldEnd()
15873 
    oprot.writeFieldStop()
15874 
    oprot.writeStructEnd()
15875 
 
15876 
  def validate(self):
15877 
    return
15878 
 
15879 
 
15880 
  def __repr__(self):
15881 
    L = ['%s=%r' % (key, value)
15882 
      for key, value in self.__dict__.iteritems()]
15883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15884 
 
15885 
  def __eq__(self, other):
15886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15887 
 
15888 
  def __ne__(self, other):
15889 
    return not (self == other)
15890 
 
6805 anupam.sin 15891 
class getInsuranceAmount_args:
15892 
  """
15893 
  Attributes:
15894 
   - itemId
6921 anupam.sin 15895 
   - price
6805 anupam.sin 15896 
   - insurerId
15897 
   - quantity
15898 
  """
15899 
 
15900 
  thrift_spec = (
15901 
    None, # 0
15902 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15903 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15904 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15905 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15906 
  )
15907 
 
6921 anupam.sin 15908 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15909 
    self.itemId = itemId
6921 anupam.sin 15910 
    self.price = price
6805 anupam.sin 15911 
    self.insurerId = insurerId
15912 
    self.quantity = quantity
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 
      elif fid == 2:
6921 anupam.sin 15929 
        if ftype == TType.DOUBLE:
15930 
          self.price = iprot.readDouble();
15931 
        else:
15932 
          iprot.skip(ftype)
15933 
      elif fid == 3:
6805 anupam.sin 15934 
        if ftype == TType.I64:
15935 
          self.insurerId = iprot.readI64();
15936 
        else:
15937 
          iprot.skip(ftype)
6921 anupam.sin 15938 
      elif fid == 4:
6805 anupam.sin 15939 
        if ftype == TType.I64:
15940 
          self.quantity = iprot.readI64();
15941 
        else:
15942 
          iprot.skip(ftype)
15943 
      else:
15944 
        iprot.skip(ftype)
15945 
      iprot.readFieldEnd()
15946 
    iprot.readStructEnd()
15947 
 
15948 
  def write(self, oprot):
15949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15951 
      return
15952 
    oprot.writeStructBegin('getInsuranceAmount_args')
15953 
    if self.itemId is not None:
15954 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15955 
      oprot.writeI64(self.itemId)
15956 
      oprot.writeFieldEnd()
6921 anupam.sin 15957 
    if self.price is not None:
15958 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15959 
      oprot.writeDouble(self.price)
15960 
      oprot.writeFieldEnd()
6805 anupam.sin 15961 
    if self.insurerId is not None:
6921 anupam.sin 15962 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15963 
      oprot.writeI64(self.insurerId)
15964 
      oprot.writeFieldEnd()
15965 
    if self.quantity is not None:
6921 anupam.sin 15966 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15967 
      oprot.writeI64(self.quantity)
15968 
      oprot.writeFieldEnd()
15969 
    oprot.writeFieldStop()
15970 
    oprot.writeStructEnd()
15971 
 
15972 
  def validate(self):
15973 
    return
15974 
 
15975 
 
15976 
  def __repr__(self):
15977 
    L = ['%s=%r' % (key, value)
15978 
      for key, value in self.__dict__.iteritems()]
15979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15980 
 
15981 
  def __eq__(self, other):
15982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15983 
 
15984 
  def __ne__(self, other):
15985 
    return not (self == other)
15986 
 
15987 
class getInsuranceAmount_result:
15988 
  """
15989 
  Attributes:
15990 
   - success
15991 
  """
15992 
 
15993 
  thrift_spec = (
15994 
    (0, TType.I64, 'success', None, None, ), # 0
15995 
  )
15996 
 
15997 
  def __init__(self, success=None,):
15998 
    self.success = success
15999 
 
16000 
  def read(self, iprot):
16001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16003 
      return
16004 
    iprot.readStructBegin()
16005 
    while True:
16006 
      (fname, ftype, fid) = iprot.readFieldBegin()
16007 
      if ftype == TType.STOP:
16008 
        break
16009 
      if fid == 0:
16010 
        if ftype == TType.I64:
16011 
          self.success = iprot.readI64();
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      else:
16015 
        iprot.skip(ftype)
16016 
      iprot.readFieldEnd()
16017 
    iprot.readStructEnd()
16018 
 
16019 
  def write(self, oprot):
16020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16022 
      return
16023 
    oprot.writeStructBegin('getInsuranceAmount_result')
16024 
    if self.success is not None:
16025 
      oprot.writeFieldBegin('success', TType.I64, 0)
16026 
      oprot.writeI64(self.success)
16027 
      oprot.writeFieldEnd()
16028 
    oprot.writeFieldStop()
16029 
    oprot.writeStructEnd()
16030 
 
16031 
  def validate(self):
16032 
    return
16033 
 
16034 
 
16035 
  def __repr__(self):
16036 
    L = ['%s=%r' % (key, value)
16037 
      for key, value in self.__dict__.iteritems()]
16038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16039 
 
16040 
  def __eq__(self, other):
16041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16042 
 
16043 
  def __ne__(self, other):
16044 
    return not (self == other)
16045 
 
16046 
class getInsurer_args:
16047 
  """
16048 
  Attributes:
16049 
   - insurerId
16050 
  """
16051 
 
16052 
  thrift_spec = (
16053 
    None, # 0
16054 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16055 
  )
16056 
 
16057 
  def __init__(self, insurerId=None,):
16058 
    self.insurerId = insurerId
16059 
 
16060 
  def read(self, iprot):
16061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16063 
      return
16064 
    iprot.readStructBegin()
16065 
    while True:
16066 
      (fname, ftype, fid) = iprot.readFieldBegin()
16067 
      if ftype == TType.STOP:
16068 
        break
16069 
      if fid == 1:
16070 
        if ftype == TType.I64:
16071 
          self.insurerId = iprot.readI64();
16072 
        else:
16073 
          iprot.skip(ftype)
16074 
      else:
16075 
        iprot.skip(ftype)
16076 
      iprot.readFieldEnd()
16077 
    iprot.readStructEnd()
16078 
 
16079 
  def write(self, oprot):
16080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16082 
      return
16083 
    oprot.writeStructBegin('getInsurer_args')
16084 
    if self.insurerId is not None:
16085 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16086 
      oprot.writeI64(self.insurerId)
16087 
      oprot.writeFieldEnd()
16088 
    oprot.writeFieldStop()
16089 
    oprot.writeStructEnd()
16090 
 
16091 
  def validate(self):
16092 
    return
16093 
 
16094 
 
16095 
  def __repr__(self):
16096 
    L = ['%s=%r' % (key, value)
16097 
      for key, value in self.__dict__.iteritems()]
16098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16099 
 
16100 
  def __eq__(self, other):
16101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16102 
 
16103 
  def __ne__(self, other):
16104 
    return not (self == other)
16105 
 
16106 
class getInsurer_result:
16107 
  """
16108 
  Attributes:
16109 
   - success
16110 
  """
16111 
 
16112 
  thrift_spec = (
16113 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
16114 
  )
16115 
 
16116 
  def __init__(self, success=None,):
16117 
    self.success = success
16118 
 
16119 
  def read(self, iprot):
16120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16122 
      return
16123 
    iprot.readStructBegin()
16124 
    while True:
16125 
      (fname, ftype, fid) = iprot.readFieldBegin()
16126 
      if ftype == TType.STOP:
16127 
        break
16128 
      if fid == 0:
16129 
        if ftype == TType.STRUCT:
16130 
          self.success = Insurer()
16131 
          self.success.read(iprot)
16132 
        else:
16133 
          iprot.skip(ftype)
16134 
      else:
16135 
        iprot.skip(ftype)
16136 
      iprot.readFieldEnd()
16137 
    iprot.readStructEnd()
16138 
 
16139 
  def write(self, oprot):
16140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16142 
      return
16143 
    oprot.writeStructBegin('getInsurer_result')
16144 
    if self.success is not None:
16145 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16146 
      self.success.write(oprot)
16147 
      oprot.writeFieldEnd()
16148 
    oprot.writeFieldStop()
16149 
    oprot.writeStructEnd()
16150 
 
16151 
  def validate(self):
16152 
    return
16153 
 
16154 
 
16155 
  def __repr__(self):
16156 
    L = ['%s=%r' % (key, value)
16157 
      for key, value in self.__dict__.iteritems()]
16158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16159 
 
16160 
  def __eq__(self, other):
16161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16162 
 
16163 
  def __ne__(self, other):
16164 
    return not (self == other)
6838 vikram.rag 16165 
 
16166 
class getAllInsurers_args:
16167 
 
16168 
  thrift_spec = (
16169 
  )
16170 
 
16171 
  def read(self, iprot):
16172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16174 
      return
16175 
    iprot.readStructBegin()
16176 
    while True:
16177 
      (fname, ftype, fid) = iprot.readFieldBegin()
16178 
      if ftype == TType.STOP:
16179 
        break
16180 
      else:
16181 
        iprot.skip(ftype)
16182 
      iprot.readFieldEnd()
16183 
    iprot.readStructEnd()
16184 
 
16185 
  def write(self, oprot):
16186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16188 
      return
16189 
    oprot.writeStructBegin('getAllInsurers_args')
16190 
    oprot.writeFieldStop()
16191 
    oprot.writeStructEnd()
16192 
 
16193 
  def validate(self):
16194 
    return
16195 
 
16196 
 
16197 
  def __repr__(self):
16198 
    L = ['%s=%r' % (key, value)
16199 
      for key, value in self.__dict__.iteritems()]
16200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16201 
 
16202 
  def __eq__(self, other):
16203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16204 
 
16205 
  def __ne__(self, other):
16206 
    return not (self == other)
16207 
 
16208 
class getAllInsurers_result:
16209 
  """
16210 
  Attributes:
16211 
   - success
16212 
  """
16213 
 
16214 
  thrift_spec = (
16215 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16216 
  )
16217 
 
16218 
  def __init__(self, success=None,):
16219 
    self.success = success
16220 
 
16221 
  def read(self, iprot):
16222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16224 
      return
16225 
    iprot.readStructBegin()
16226 
    while True:
16227 
      (fname, ftype, fid) = iprot.readFieldBegin()
16228 
      if ftype == TType.STOP:
16229 
        break
16230 
      if fid == 0:
16231 
        if ftype == TType.LIST:
16232 
          self.success = []
7438 amit.gupta 16233 
          (_etype310, _size307) = iprot.readListBegin()
16234 
          for _i311 in xrange(_size307):
16235 
            _elem312 = Insurer()
16236 
            _elem312.read(iprot)
16237 
            self.success.append(_elem312)
6838 vikram.rag 16238 
          iprot.readListEnd()
16239 
        else:
16240 
          iprot.skip(ftype)
16241 
      else:
16242 
        iprot.skip(ftype)
16243 
      iprot.readFieldEnd()
16244 
    iprot.readStructEnd()
16245 
 
16246 
  def write(self, oprot):
16247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16249 
      return
16250 
    oprot.writeStructBegin('getAllInsurers_result')
16251 
    if self.success is not None:
16252 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16253 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16254 
      for iter313 in self.success:
16255 
        iter313.write(oprot)
6838 vikram.rag 16256 
      oprot.writeListEnd()
16257 
      oprot.writeFieldEnd()
16258 
    oprot.writeFieldStop()
16259 
    oprot.writeStructEnd()
16260 
 
16261 
  def validate(self):
16262 
    return
16263 
 
16264 
 
16265 
  def __repr__(self):
16266 
    L = ['%s=%r' % (key, value)
16267 
      for key, value in self.__dict__.iteritems()]
16268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16269 
 
16270 
  def __eq__(self, other):
16271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16272 
 
16273 
  def __ne__(self, other):
16274 
    return not (self == other)
6962 rajveer 16275 
 
16276 
class updateInsuranceDeclaredAmount_args:
16277 
  """
16278 
  Attributes:
16279 
   - insurerId
16280 
   - amount
16281 
  """
16282 
 
16283 
  thrift_spec = (
16284 
    None, # 0
16285 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16286 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16287 
  )
16288 
 
16289 
  def __init__(self, insurerId=None, amount=None,):
16290 
    self.insurerId = insurerId
16291 
    self.amount = amount
16292 
 
16293 
  def read(self, iprot):
16294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16296 
      return
16297 
    iprot.readStructBegin()
16298 
    while True:
16299 
      (fname, ftype, fid) = iprot.readFieldBegin()
16300 
      if ftype == TType.STOP:
16301 
        break
16302 
      if fid == 1:
16303 
        if ftype == TType.I64:
16304 
          self.insurerId = iprot.readI64();
16305 
        else:
16306 
          iprot.skip(ftype)
16307 
      elif fid == 2:
16308 
        if ftype == TType.DOUBLE:
16309 
          self.amount = iprot.readDouble();
16310 
        else:
16311 
          iprot.skip(ftype)
16312 
      else:
16313 
        iprot.skip(ftype)
16314 
      iprot.readFieldEnd()
16315 
    iprot.readStructEnd()
16316 
 
16317 
  def write(self, oprot):
16318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16320 
      return
16321 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16322 
    if self.insurerId is not None:
16323 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16324 
      oprot.writeI64(self.insurerId)
16325 
      oprot.writeFieldEnd()
16326 
    if self.amount is not None:
16327 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16328 
      oprot.writeDouble(self.amount)
16329 
      oprot.writeFieldEnd()
16330 
    oprot.writeFieldStop()
16331 
    oprot.writeStructEnd()
16332 
 
16333 
  def validate(self):
16334 
    return
16335 
 
16336 
 
16337 
  def __repr__(self):
16338 
    L = ['%s=%r' % (key, value)
16339 
      for key, value in self.__dict__.iteritems()]
16340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16341 
 
16342 
  def __eq__(self, other):
16343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16344 
 
16345 
  def __ne__(self, other):
16346 
    return not (self == other)
16347 
 
16348 
class updateInsuranceDeclaredAmount_result:
16349 
 
16350 
  thrift_spec = (
16351 
  )
16352 
 
16353 
  def read(self, iprot):
16354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16356 
      return
16357 
    iprot.readStructBegin()
16358 
    while True:
16359 
      (fname, ftype, fid) = iprot.readFieldBegin()
16360 
      if ftype == TType.STOP:
16361 
        break
16362 
      else:
16363 
        iprot.skip(ftype)
16364 
      iprot.readFieldEnd()
16365 
    iprot.readStructEnd()
16366 
 
16367 
  def write(self, oprot):
16368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16370 
      return
16371 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16372 
    oprot.writeFieldStop()
16373 
    oprot.writeStructEnd()
16374 
 
16375 
  def validate(self):
16376 
    return
16377 
 
16378 
 
16379 
  def __repr__(self):
16380 
    L = ['%s=%r' % (key, value)
16381 
      for key, value in self.__dict__.iteritems()]
16382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16383 
 
16384 
  def __eq__(self, other):
16385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16386 
 
16387 
  def __ne__(self, other):
16388 
    return not (self == other)
7190 amar.kumar 16389 
 
16390 
class getFreebieForItem_args:
16391 
  """
16392 
  Attributes:
16393 
   - itemId
16394 
  """
16395 
 
16396 
  thrift_spec = (
16397 
    None, # 0
16398 
    (1, TType.I64, 'itemId', None, None, ), # 1
16399 
  )
16400 
 
16401 
  def __init__(self, itemId=None,):
16402 
    self.itemId = itemId
16403 
 
16404 
  def read(self, iprot):
16405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16407 
      return
16408 
    iprot.readStructBegin()
16409 
    while True:
16410 
      (fname, ftype, fid) = iprot.readFieldBegin()
16411 
      if ftype == TType.STOP:
16412 
        break
16413 
      if fid == 1:
16414 
        if ftype == TType.I64:
16415 
          self.itemId = iprot.readI64();
16416 
        else:
16417 
          iprot.skip(ftype)
16418 
      else:
16419 
        iprot.skip(ftype)
16420 
      iprot.readFieldEnd()
16421 
    iprot.readStructEnd()
16422 
 
16423 
  def write(self, oprot):
16424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16426 
      return
16427 
    oprot.writeStructBegin('getFreebieForItem_args')
16428 
    if self.itemId is not None:
16429 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16430 
      oprot.writeI64(self.itemId)
16431 
      oprot.writeFieldEnd()
16432 
    oprot.writeFieldStop()
16433 
    oprot.writeStructEnd()
16434 
 
16435 
  def validate(self):
16436 
    return
16437 
 
16438 
 
16439 
  def __repr__(self):
16440 
    L = ['%s=%r' % (key, value)
16441 
      for key, value in self.__dict__.iteritems()]
16442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16443 
 
16444 
  def __eq__(self, other):
16445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16446 
 
16447 
  def __ne__(self, other):
16448 
    return not (self == other)
16449 
 
16450 
class getFreebieForItem_result:
16451 
  """
16452 
  Attributes:
16453 
   - success
16454 
  """
16455 
 
16456 
  thrift_spec = (
16457 
    (0, TType.I64, 'success', None, None, ), # 0
16458 
  )
16459 
 
16460 
  def __init__(self, success=None,):
16461 
    self.success = success
16462 
 
16463 
  def read(self, iprot):
16464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16466 
      return
16467 
    iprot.readStructBegin()
16468 
    while True:
16469 
      (fname, ftype, fid) = iprot.readFieldBegin()
16470 
      if ftype == TType.STOP:
16471 
        break
16472 
      if fid == 0:
16473 
        if ftype == TType.I64:
16474 
          self.success = iprot.readI64();
16475 
        else:
16476 
          iprot.skip(ftype)
16477 
      else:
16478 
        iprot.skip(ftype)
16479 
      iprot.readFieldEnd()
16480 
    iprot.readStructEnd()
16481 
 
16482 
  def write(self, oprot):
16483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16485 
      return
16486 
    oprot.writeStructBegin('getFreebieForItem_result')
16487 
    if self.success is not None:
16488 
      oprot.writeFieldBegin('success', TType.I64, 0)
16489 
      oprot.writeI64(self.success)
16490 
      oprot.writeFieldEnd()
16491 
    oprot.writeFieldStop()
16492 
    oprot.writeStructEnd()
16493 
 
16494 
  def validate(self):
16495 
    return
16496 
 
16497 
 
16498 
  def __repr__(self):
16499 
    L = ['%s=%r' % (key, value)
16500 
      for key, value in self.__dict__.iteritems()]
16501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16502 
 
16503 
  def __eq__(self, other):
16504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16505 
 
16506 
  def __ne__(self, other):
16507 
    return not (self == other)
16508 
 
16509 
class addOrUpdateFreebieForItem_args:
16510 
  """
16511 
  Attributes:
16512 
   - freebieItem
16513 
  """
16514 
 
16515 
  thrift_spec = (
16516 
    None, # 0
16517 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16518 
  )
16519 
 
16520 
  def __init__(self, freebieItem=None,):
16521 
    self.freebieItem = freebieItem
16522 
 
16523 
  def read(self, iprot):
16524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16526 
      return
16527 
    iprot.readStructBegin()
16528 
    while True:
16529 
      (fname, ftype, fid) = iprot.readFieldBegin()
16530 
      if ftype == TType.STOP:
16531 
        break
16532 
      if fid == 1:
16533 
        if ftype == TType.STRUCT:
16534 
          self.freebieItem = FreebieItem()
16535 
          self.freebieItem.read(iprot)
16536 
        else:
16537 
          iprot.skip(ftype)
16538 
      else:
16539 
        iprot.skip(ftype)
16540 
      iprot.readFieldEnd()
16541 
    iprot.readStructEnd()
16542 
 
16543 
  def write(self, oprot):
16544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16546 
      return
16547 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16548 
    if self.freebieItem is not None:
16549 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16550 
      self.freebieItem.write(oprot)
16551 
      oprot.writeFieldEnd()
16552 
    oprot.writeFieldStop()
16553 
    oprot.writeStructEnd()
16554 
 
16555 
  def validate(self):
16556 
    return
16557 
 
16558 
 
16559 
  def __repr__(self):
16560 
    L = ['%s=%r' % (key, value)
16561 
      for key, value in self.__dict__.iteritems()]
16562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16563 
 
16564 
  def __eq__(self, other):
16565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16566 
 
16567 
  def __ne__(self, other):
16568 
    return not (self == other)
16569 
 
16570 
class addOrUpdateFreebieForItem_result:
16571 
 
16572 
  thrift_spec = (
16573 
  )
16574 
 
16575 
  def read(self, iprot):
16576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16578 
      return
16579 
    iprot.readStructBegin()
16580 
    while True:
16581 
      (fname, ftype, fid) = iprot.readFieldBegin()
16582 
      if ftype == TType.STOP:
16583 
        break
16584 
      else:
16585 
        iprot.skip(ftype)
16586 
      iprot.readFieldEnd()
16587 
    iprot.readStructEnd()
16588 
 
16589 
  def write(self, oprot):
16590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16592 
      return
16593 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16594 
    oprot.writeFieldStop()
16595 
    oprot.writeStructEnd()
16596 
 
16597 
  def validate(self):
16598 
    return
16599 
 
16600 
 
16601 
  def __repr__(self):
16602 
    L = ['%s=%r' % (key, value)
16603 
      for key, value in self.__dict__.iteritems()]
16604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16605 
 
16606 
  def __eq__(self, other):
16607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16608 
 
16609 
  def __ne__(self, other):
16610 
    return not (self == other)
7256 rajveer 16611 
 
7272 amit.gupta 16612 
class addOrUpdateBrandInfo_args:
16613 
  """
16614 
  Attributes:
16615 
   - brandInfo
16616 
  """
16617 
 
16618 
  thrift_spec = (
16619 
    None, # 0
16620 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16621 
  )
16622 
 
16623 
  def __init__(self, brandInfo=None,):
16624 
    self.brandInfo = brandInfo
16625 
 
16626 
  def read(self, iprot):
16627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16629 
      return
16630 
    iprot.readStructBegin()
16631 
    while True:
16632 
      (fname, ftype, fid) = iprot.readFieldBegin()
16633 
      if ftype == TType.STOP:
16634 
        break
16635 
      if fid == 1:
16636 
        if ftype == TType.STRUCT:
16637 
          self.brandInfo = BrandInfo()
16638 
          self.brandInfo.read(iprot)
16639 
        else:
16640 
          iprot.skip(ftype)
16641 
      else:
16642 
        iprot.skip(ftype)
16643 
      iprot.readFieldEnd()
16644 
    iprot.readStructEnd()
16645 
 
16646 
  def write(self, oprot):
16647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16649 
      return
16650 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16651 
    if self.brandInfo is not None:
16652 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16653 
      self.brandInfo.write(oprot)
16654 
      oprot.writeFieldEnd()
16655 
    oprot.writeFieldStop()
16656 
    oprot.writeStructEnd()
16657 
 
16658 
  def validate(self):
16659 
    return
16660 
 
16661 
 
16662 
  def __repr__(self):
16663 
    L = ['%s=%r' % (key, value)
16664 
      for key, value in self.__dict__.iteritems()]
16665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16666 
 
16667 
  def __eq__(self, other):
16668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16669 
 
16670 
  def __ne__(self, other):
16671 
    return not (self == other)
16672 
 
16673 
class addOrUpdateBrandInfo_result:
16674 
 
16675 
  thrift_spec = (
16676 
  )
16677 
 
16678 
  def read(self, iprot):
16679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16681 
      return
16682 
    iprot.readStructBegin()
16683 
    while True:
16684 
      (fname, ftype, fid) = iprot.readFieldBegin()
16685 
      if ftype == TType.STOP:
16686 
        break
16687 
      else:
16688 
        iprot.skip(ftype)
16689 
      iprot.readFieldEnd()
16690 
    iprot.readStructEnd()
16691 
 
16692 
  def write(self, oprot):
16693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16695 
      return
16696 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16697 
    oprot.writeFieldStop()
16698 
    oprot.writeStructEnd()
16699 
 
16700 
  def validate(self):
16701 
    return
16702 
 
16703 
 
16704 
  def __repr__(self):
16705 
    L = ['%s=%r' % (key, value)
16706 
      for key, value in self.__dict__.iteritems()]
16707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16708 
 
16709 
  def __eq__(self, other):
16710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16711 
 
16712 
  def __ne__(self, other):
16713 
    return not (self == other)
16714 
 
16715 
class getBrandInfo_args:
16716 
 
16717 
  thrift_spec = (
16718 
  )
16719 
 
16720 
  def read(self, iprot):
16721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16723 
      return
16724 
    iprot.readStructBegin()
16725 
    while True:
16726 
      (fname, ftype, fid) = iprot.readFieldBegin()
16727 
      if ftype == TType.STOP:
16728 
        break
16729 
      else:
16730 
        iprot.skip(ftype)
16731 
      iprot.readFieldEnd()
16732 
    iprot.readStructEnd()
16733 
 
16734 
  def write(self, oprot):
16735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16737 
      return
16738 
    oprot.writeStructBegin('getBrandInfo_args')
16739 
    oprot.writeFieldStop()
16740 
    oprot.writeStructEnd()
16741 
 
16742 
  def validate(self):
16743 
    return
16744 
 
16745 
 
16746 
  def __repr__(self):
16747 
    L = ['%s=%r' % (key, value)
16748 
      for key, value in self.__dict__.iteritems()]
16749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16750 
 
16751 
  def __eq__(self, other):
16752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16753 
 
16754 
  def __ne__(self, other):
16755 
    return not (self == other)
16756 
 
16757 
class getBrandInfo_result:
16758 
  """
16759 
  Attributes:
16760 
   - success
16761 
  """
16762 
 
16763 
  thrift_spec = (
16764 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16765 
  )
16766 
 
16767 
  def __init__(self, success=None,):
16768 
    self.success = success
16769 
 
16770 
  def read(self, iprot):
16771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16773 
      return
16774 
    iprot.readStructBegin()
16775 
    while True:
16776 
      (fname, ftype, fid) = iprot.readFieldBegin()
16777 
      if ftype == TType.STOP:
16778 
        break
16779 
      if fid == 0:
16780 
        if ftype == TType.MAP:
16781 
          self.success = {}
7438 amit.gupta 16782 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16783 
          for _i318 in xrange(_size314):
16784 
            _key319 = iprot.readString();
16785 
            _val320 = BrandInfo()
16786 
            _val320.read(iprot)
16787 
            self.success[_key319] = _val320
7272 amit.gupta 16788 
          iprot.readMapEnd()
16789 
        else:
16790 
          iprot.skip(ftype)
16791 
      else:
16792 
        iprot.skip(ftype)
16793 
      iprot.readFieldEnd()
16794 
    iprot.readStructEnd()
16795 
 
16796 
  def write(self, oprot):
16797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16799 
      return
16800 
    oprot.writeStructBegin('getBrandInfo_result')
16801 
    if self.success is not None:
16802 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16803 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16804 
      for kiter321,viter322 in self.success.items():
16805 
        oprot.writeString(kiter321)
16806 
        viter322.write(oprot)
7272 amit.gupta 16807 
      oprot.writeMapEnd()
16808 
      oprot.writeFieldEnd()
16809 
    oprot.writeFieldStop()
16810 
    oprot.writeStructEnd()
16811 
 
16812 
  def validate(self):
16813 
    return
16814 
 
16815 
 
16816 
  def __repr__(self):
16817 
    L = ['%s=%r' % (key, value)
16818 
      for key, value in self.__dict__.iteritems()]
16819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16820 
 
16821 
  def __eq__(self, other):
16822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16823 
 
16824 
  def __ne__(self, other):
16825 
    return not (self == other)
16826 
 
7256 rajveer 16827 
class getStorePricing_args:
16828 
  """
16829 
  Attributes:
16830 
   - itemId
16831 
  """
16832 
 
16833 
  thrift_spec = (
16834 
    None, # 0
16835 
    (1, TType.I64, 'itemId', None, None, ), # 1
16836 
  )
16837 
 
16838 
  def __init__(self, itemId=None,):
16839 
    self.itemId = itemId
16840 
 
16841 
  def read(self, iprot):
16842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16844 
      return
16845 
    iprot.readStructBegin()
16846 
    while True:
16847 
      (fname, ftype, fid) = iprot.readFieldBegin()
16848 
      if ftype == TType.STOP:
16849 
        break
16850 
      if fid == 1:
16851 
        if ftype == TType.I64:
16852 
          self.itemId = iprot.readI64();
16853 
        else:
16854 
          iprot.skip(ftype)
16855 
      else:
16856 
        iprot.skip(ftype)
16857 
      iprot.readFieldEnd()
16858 
    iprot.readStructEnd()
16859 
 
16860 
  def write(self, oprot):
16861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16863 
      return
16864 
    oprot.writeStructBegin('getStorePricing_args')
16865 
    if self.itemId is not None:
16866 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16867 
      oprot.writeI64(self.itemId)
16868 
      oprot.writeFieldEnd()
16869 
    oprot.writeFieldStop()
16870 
    oprot.writeStructEnd()
16871 
 
16872 
  def validate(self):
16873 
    return
16874 
 
16875 
 
16876 
  def __repr__(self):
16877 
    L = ['%s=%r' % (key, value)
16878 
      for key, value in self.__dict__.iteritems()]
16879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16880 
 
16881 
  def __eq__(self, other):
16882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16883 
 
16884 
  def __ne__(self, other):
16885 
    return not (self == other)
16886 
 
16887 
class getStorePricing_result:
16888 
  """
16889 
  Attributes:
16890 
   - success
16891 
  """
16892 
 
16893 
  thrift_spec = (
16894 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16895 
  )
16896 
 
16897 
  def __init__(self, success=None,):
16898 
    self.success = success
16899 
 
16900 
  def read(self, iprot):
16901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16903 
      return
16904 
    iprot.readStructBegin()
16905 
    while True:
16906 
      (fname, ftype, fid) = iprot.readFieldBegin()
16907 
      if ftype == TType.STOP:
16908 
        break
16909 
      if fid == 0:
16910 
        if ftype == TType.STRUCT:
16911 
          self.success = StorePricing()
16912 
          self.success.read(iprot)
16913 
        else:
16914 
          iprot.skip(ftype)
16915 
      else:
16916 
        iprot.skip(ftype)
16917 
      iprot.readFieldEnd()
16918 
    iprot.readStructEnd()
16919 
 
16920 
  def write(self, oprot):
16921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16923 
      return
16924 
    oprot.writeStructBegin('getStorePricing_result')
16925 
    if self.success is not None:
16926 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16927 
      self.success.write(oprot)
16928 
      oprot.writeFieldEnd()
16929 
    oprot.writeFieldStop()
16930 
    oprot.writeStructEnd()
16931 
 
16932 
  def validate(self):
16933 
    return
16934 
 
16935 
 
16936 
  def __repr__(self):
16937 
    L = ['%s=%r' % (key, value)
16938 
      for key, value in self.__dict__.iteritems()]
16939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16940 
 
16941 
  def __eq__(self, other):
16942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16943 
 
16944 
  def __ne__(self, other):
16945 
    return not (self == other)
7265 rajveer 16946 
 
7306 rajveer 16947 
class getStorePricings_args:
16948 
  """
16949 
  Attributes:
16950 
   - itemIds
16951 
  """
16952 
 
16953 
  thrift_spec = (
16954 
    None, # 0
16955 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16956 
  )
16957 
 
16958 
  def __init__(self, itemIds=None,):
16959 
    self.itemIds = itemIds
16960 
 
16961 
  def read(self, iprot):
16962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16964 
      return
16965 
    iprot.readStructBegin()
16966 
    while True:
16967 
      (fname, ftype, fid) = iprot.readFieldBegin()
16968 
      if ftype == TType.STOP:
16969 
        break
16970 
      if fid == 1:
16971 
        if ftype == TType.LIST:
16972 
          self.itemIds = []
7438 amit.gupta 16973 
          (_etype326, _size323) = iprot.readListBegin()
16974 
          for _i327 in xrange(_size323):
16975 
            _elem328 = iprot.readI64();
16976 
            self.itemIds.append(_elem328)
7306 rajveer 16977 
          iprot.readListEnd()
16978 
        else:
16979 
          iprot.skip(ftype)
16980 
      else:
16981 
        iprot.skip(ftype)
16982 
      iprot.readFieldEnd()
16983 
    iprot.readStructEnd()
16984 
 
16985 
  def write(self, oprot):
16986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16988 
      return
16989 
    oprot.writeStructBegin('getStorePricings_args')
16990 
    if self.itemIds is not None:
16991 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16992 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 16993 
      for iter329 in self.itemIds:
16994 
        oprot.writeI64(iter329)
7306 rajveer 16995 
      oprot.writeListEnd()
16996 
      oprot.writeFieldEnd()
16997 
    oprot.writeFieldStop()
16998 
    oprot.writeStructEnd()
16999 
 
17000 
  def validate(self):
17001 
    return
17002 
 
17003 
 
17004 
  def __repr__(self):
17005 
    L = ['%s=%r' % (key, value)
17006 
      for key, value in self.__dict__.iteritems()]
17007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17008 
 
17009 
  def __eq__(self, other):
17010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17011 
 
17012 
  def __ne__(self, other):
17013 
    return not (self == other)
17014 
 
17015 
class getStorePricings_result:
17016 
  """
17017 
  Attributes:
17018 
   - success
17019 
  """
17020 
 
17021 
  thrift_spec = (
17022 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
17023 
  )
17024 
 
17025 
  def __init__(self, success=None,):
17026 
    self.success = success
17027 
 
17028 
  def read(self, iprot):
17029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17031 
      return
17032 
    iprot.readStructBegin()
17033 
    while True:
17034 
      (fname, ftype, fid) = iprot.readFieldBegin()
17035 
      if ftype == TType.STOP:
17036 
        break
17037 
      if fid == 0:
17038 
        if ftype == TType.LIST:
17039 
          self.success = []
7438 amit.gupta 17040 
          (_etype333, _size330) = iprot.readListBegin()
17041 
          for _i334 in xrange(_size330):
17042 
            _elem335 = StorePricing()
17043 
            _elem335.read(iprot)
17044 
            self.success.append(_elem335)
7306 rajveer 17045 
          iprot.readListEnd()
17046 
        else:
17047 
          iprot.skip(ftype)
17048 
      else:
17049 
        iprot.skip(ftype)
17050 
      iprot.readFieldEnd()
17051 
    iprot.readStructEnd()
17052 
 
17053 
  def write(self, oprot):
17054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17056 
      return
17057 
    oprot.writeStructBegin('getStorePricings_result')
17058 
    if self.success is not None:
17059 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17060 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17061 
      for iter336 in self.success:
17062 
        iter336.write(oprot)
7306 rajveer 17063 
      oprot.writeListEnd()
17064 
      oprot.writeFieldEnd()
17065 
    oprot.writeFieldStop()
17066 
    oprot.writeStructEnd()
17067 
 
17068 
  def validate(self):
17069 
    return
17070 
 
17071 
 
17072 
  def __repr__(self):
17073 
    L = ['%s=%r' % (key, value)
17074 
      for key, value in self.__dict__.iteritems()]
17075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17076 
 
17077 
  def __eq__(self, other):
17078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17079 
 
17080 
  def __ne__(self, other):
17081 
    return not (self == other)
17082 
 
7265 rajveer 17083 
class updateStorePricing_args:
17084 
  """
17085 
  Attributes:
17086 
   - sp
7382 rajveer 17087 
   - allColors
7265 rajveer 17088 
  """
17089 
 
17090 
  thrift_spec = (
17091 
    None, # 0
17092 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 17093 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 17094 
  )
17095 
 
7382 rajveer 17096 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 17097 
    self.sp = sp
7382 rajveer 17098 
    self.allColors = allColors
7265 rajveer 17099 
 
17100 
  def read(self, iprot):
17101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17103 
      return
17104 
    iprot.readStructBegin()
17105 
    while True:
17106 
      (fname, ftype, fid) = iprot.readFieldBegin()
17107 
      if ftype == TType.STOP:
17108 
        break
17109 
      if fid == 1:
17110 
        if ftype == TType.STRUCT:
17111 
          self.sp = StorePricing()
17112 
          self.sp.read(iprot)
17113 
        else:
17114 
          iprot.skip(ftype)
7382 rajveer 17115 
      elif fid == 2:
17116 
        if ftype == TType.BOOL:
17117 
          self.allColors = iprot.readBool();
17118 
        else:
17119 
          iprot.skip(ftype)
7265 rajveer 17120 
      else:
17121 
        iprot.skip(ftype)
17122 
      iprot.readFieldEnd()
17123 
    iprot.readStructEnd()
17124 
 
17125 
  def write(self, oprot):
17126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17128 
      return
17129 
    oprot.writeStructBegin('updateStorePricing_args')
17130 
    if self.sp is not None:
17131 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
17132 
      self.sp.write(oprot)
17133 
      oprot.writeFieldEnd()
7382 rajveer 17134 
    if self.allColors is not None:
17135 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
17136 
      oprot.writeBool(self.allColors)
17137 
      oprot.writeFieldEnd()
7265 rajveer 17138 
    oprot.writeFieldStop()
17139 
    oprot.writeStructEnd()
17140 
 
17141 
  def validate(self):
17142 
    return
17143 
 
17144 
 
17145 
  def __repr__(self):
17146 
    L = ['%s=%r' % (key, value)
17147 
      for key, value in self.__dict__.iteritems()]
17148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17149 
 
17150 
  def __eq__(self, other):
17151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17152 
 
17153 
  def __ne__(self, other):
17154 
    return not (self == other)
17155 
 
17156 
class updateStorePricing_result:
17157 
 
17158 
  thrift_spec = (
17159 
  )
17160 
 
17161 
  def read(self, iprot):
17162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17164 
      return
17165 
    iprot.readStructBegin()
17166 
    while True:
17167 
      (fname, ftype, fid) = iprot.readFieldBegin()
17168 
      if ftype == TType.STOP:
17169 
        break
17170 
      else:
17171 
        iprot.skip(ftype)
17172 
      iprot.readFieldEnd()
17173 
    iprot.readStructEnd()
17174 
 
17175 
  def write(self, oprot):
17176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17178 
      return
17179 
    oprot.writeStructBegin('updateStorePricing_result')
17180 
    oprot.writeFieldStop()
17181 
    oprot.writeStructEnd()
17182 
 
17183 
  def validate(self):
17184 
    return
17185 
 
17186 
 
17187 
  def __repr__(self):
17188 
    L = ['%s=%r' % (key, value)
17189 
      for key, value in self.__dict__.iteritems()]
17190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17191 
 
17192 
  def __eq__(self, other):
17193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17194 
 
17195 
  def __ne__(self, other):
17196 
    return not (self == other)
7281 kshitij.so 17197 
 
17198 
class getAllAmazonListedItems_args:
17199 
 
17200 
  thrift_spec = (
17201 
  )
17202 
 
17203 
  def read(self, iprot):
17204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17206 
      return
17207 
    iprot.readStructBegin()
17208 
    while True:
17209 
      (fname, ftype, fid) = iprot.readFieldBegin()
17210 
      if ftype == TType.STOP:
17211 
        break
17212 
      else:
17213 
        iprot.skip(ftype)
17214 
      iprot.readFieldEnd()
17215 
    iprot.readStructEnd()
17216 
 
17217 
  def write(self, oprot):
17218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17220 
      return
17221 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17222 
    oprot.writeFieldStop()
17223 
    oprot.writeStructEnd()
17224 
 
17225 
  def validate(self):
17226 
    return
17227 
 
17228 
 
17229 
  def __repr__(self):
17230 
    L = ['%s=%r' % (key, value)
17231 
      for key, value in self.__dict__.iteritems()]
17232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17233 
 
17234 
  def __eq__(self, other):
17235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17236 
 
17237 
  def __ne__(self, other):
17238 
    return not (self == other)
17239 
 
17240 
class getAllAmazonListedItems_result:
17241 
  """
17242 
  Attributes:
17243 
   - success
17244 
  """
17245 
 
17246 
  thrift_spec = (
17247 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17248 
  )
17249 
 
17250 
  def __init__(self, success=None,):
17251 
    self.success = success
17252 
 
17253 
  def read(self, iprot):
17254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17256 
      return
17257 
    iprot.readStructBegin()
17258 
    while True:
17259 
      (fname, ftype, fid) = iprot.readFieldBegin()
17260 
      if ftype == TType.STOP:
17261 
        break
17262 
      if fid == 0:
17263 
        if ftype == TType.LIST:
17264 
          self.success = []
7438 amit.gupta 17265 
          (_etype340, _size337) = iprot.readListBegin()
17266 
          for _i341 in xrange(_size337):
17267 
            _elem342 = Amazonlisted()
17268 
            _elem342.read(iprot)
17269 
            self.success.append(_elem342)
7281 kshitij.so 17270 
          iprot.readListEnd()
17271 
        else:
17272 
          iprot.skip(ftype)
17273 
      else:
17274 
        iprot.skip(ftype)
17275 
      iprot.readFieldEnd()
17276 
    iprot.readStructEnd()
17277 
 
17278 
  def write(self, oprot):
17279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17281 
      return
17282 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17283 
    if self.success is not None:
17284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17286 
      for iter343 in self.success:
17287 
        iter343.write(oprot)
7281 kshitij.so 17288 
      oprot.writeListEnd()
17289 
      oprot.writeFieldEnd()
17290 
    oprot.writeFieldStop()
17291 
    oprot.writeStructEnd()
17292 
 
17293 
  def validate(self):
17294 
    return
17295 
 
17296 
 
17297 
  def __repr__(self):
17298 
    L = ['%s=%r' % (key, value)
17299 
      for key, value in self.__dict__.iteritems()]
17300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17301 
 
17302 
  def __eq__(self, other):
17303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17304 
 
17305 
  def __ne__(self, other):
17306 
    return not (self == other)
17307 
 
17308 
class getAmazonItemDetails_args:
17309 
  """
17310 
  Attributes:
17311 
   - itemId
17312 
  """
17313 
 
17314 
  thrift_spec = (
17315 
    None, # 0
17316 
    (1, TType.I64, 'itemId', None, None, ), # 1
17317 
  )
17318 
 
17319 
  def __init__(self, itemId=None,):
17320 
    self.itemId = itemId
17321 
 
17322 
  def read(self, iprot):
17323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17325 
      return
17326 
    iprot.readStructBegin()
17327 
    while True:
17328 
      (fname, ftype, fid) = iprot.readFieldBegin()
17329 
      if ftype == TType.STOP:
17330 
        break
17331 
      if fid == 1:
17332 
        if ftype == TType.I64:
17333 
          self.itemId = iprot.readI64();
17334 
        else:
17335 
          iprot.skip(ftype)
17336 
      else:
17337 
        iprot.skip(ftype)
17338 
      iprot.readFieldEnd()
17339 
    iprot.readStructEnd()
17340 
 
17341 
  def write(self, oprot):
17342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17344 
      return
17345 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17346 
    if self.itemId is not None:
17347 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17348 
      oprot.writeI64(self.itemId)
17349 
      oprot.writeFieldEnd()
17350 
    oprot.writeFieldStop()
17351 
    oprot.writeStructEnd()
17352 
 
17353 
  def validate(self):
17354 
    return
17355 
 
17356 
 
17357 
  def __repr__(self):
17358 
    L = ['%s=%r' % (key, value)
17359 
      for key, value in self.__dict__.iteritems()]
17360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17361 
 
17362 
  def __eq__(self, other):
17363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17364 
 
17365 
  def __ne__(self, other):
17366 
    return not (self == other)
17367 
 
17368 
class getAmazonItemDetails_result:
17369 
  """
17370 
  Attributes:
17371 
   - success
17372 
  """
17373 
 
17374 
  thrift_spec = (
17375 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17376 
  )
17377 
 
17378 
  def __init__(self, success=None,):
17379 
    self.success = success
17380 
 
17381 
  def read(self, iprot):
17382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17384 
      return
17385 
    iprot.readStructBegin()
17386 
    while True:
17387 
      (fname, ftype, fid) = iprot.readFieldBegin()
17388 
      if ftype == TType.STOP:
17389 
        break
17390 
      if fid == 0:
17391 
        if ftype == TType.STRUCT:
17392 
          self.success = Amazonlisted()
17393 
          self.success.read(iprot)
17394 
        else:
17395 
          iprot.skip(ftype)
17396 
      else:
17397 
        iprot.skip(ftype)
17398 
      iprot.readFieldEnd()
17399 
    iprot.readStructEnd()
17400 
 
17401 
  def write(self, oprot):
17402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17404 
      return
17405 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17406 
    if self.success is not None:
17407 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17408 
      self.success.write(oprot)
17409 
      oprot.writeFieldEnd()
17410 
    oprot.writeFieldStop()
17411 
    oprot.writeStructEnd()
17412 
 
17413 
  def validate(self):
17414 
    return
17415 
 
17416 
 
17417 
  def __repr__(self):
17418 
    L = ['%s=%r' % (key, value)
17419 
      for key, value in self.__dict__.iteritems()]
17420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17421 
 
17422 
  def __eq__(self, other):
17423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17424 
 
17425 
  def __ne__(self, other):
17426 
    return not (self == other)
17427 
 
17428 
class updateAmazonItemDetails_args:
17429 
  """
17430 
  Attributes:
17431 
   - itemId
17432 
   - fbaPrice
17433 
   - sellingPrice
17434 
   - isFba
17435 
   - isNonFba
17436 
   - isInventoryOverride
7367 kshitij.so 17437 
   - handlingTime
17438 
   - isCustomTime
7281 kshitij.so 17439 
  """
17440 
 
17441 
  thrift_spec = (
17442 
    None, # 0
17443 
    (1, TType.I64, 'itemId', None, None, ), # 1
17444 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
17445 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
17446 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
17447 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
17448 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 17449 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
17450 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 17451 
  )
17452 
 
7367 kshitij.so 17453 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 17454 
    self.itemId = itemId
17455 
    self.fbaPrice = fbaPrice
17456 
    self.sellingPrice = sellingPrice
17457 
    self.isFba = isFba
17458 
    self.isNonFba = isNonFba
17459 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 17460 
    self.handlingTime = handlingTime
17461 
    self.isCustomTime = isCustomTime
7281 kshitij.so 17462 
 
17463 
  def read(self, iprot):
17464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17466 
      return
17467 
    iprot.readStructBegin()
17468 
    while True:
17469 
      (fname, ftype, fid) = iprot.readFieldBegin()
17470 
      if ftype == TType.STOP:
17471 
        break
17472 
      if fid == 1:
17473 
        if ftype == TType.I64:
17474 
          self.itemId = iprot.readI64();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      elif fid == 2:
17478 
        if ftype == TType.DOUBLE:
17479 
          self.fbaPrice = iprot.readDouble();
17480 
        else:
17481 
          iprot.skip(ftype)
17482 
      elif fid == 3:
17483 
        if ftype == TType.DOUBLE:
17484 
          self.sellingPrice = iprot.readDouble();
17485 
        else:
17486 
          iprot.skip(ftype)
17487 
      elif fid == 4:
17488 
        if ftype == TType.BOOL:
17489 
          self.isFba = iprot.readBool();
17490 
        else:
17491 
          iprot.skip(ftype)
17492 
      elif fid == 5:
17493 
        if ftype == TType.BOOL:
17494 
          self.isNonFba = iprot.readBool();
17495 
        else:
17496 
          iprot.skip(ftype)
17497 
      elif fid == 6:
17498 
        if ftype == TType.BOOL:
17499 
          self.isInventoryOverride = iprot.readBool();
17500 
        else:
17501 
          iprot.skip(ftype)
7367 kshitij.so 17502 
      elif fid == 7:
17503 
        if ftype == TType.I64:
17504 
          self.handlingTime = iprot.readI64();
17505 
        else:
17506 
          iprot.skip(ftype)
17507 
      elif fid == 8:
17508 
        if ftype == TType.BOOL:
17509 
          self.isCustomTime = iprot.readBool();
17510 
        else:
17511 
          iprot.skip(ftype)
7281 kshitij.so 17512 
      else:
17513 
        iprot.skip(ftype)
17514 
      iprot.readFieldEnd()
17515 
    iprot.readStructEnd()
17516 
 
17517 
  def write(self, oprot):
17518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17520 
      return
17521 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17522 
    if self.itemId is not None:
17523 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17524 
      oprot.writeI64(self.itemId)
17525 
      oprot.writeFieldEnd()
17526 
    if self.fbaPrice is not None:
17527 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17528 
      oprot.writeDouble(self.fbaPrice)
17529 
      oprot.writeFieldEnd()
17530 
    if self.sellingPrice is not None:
17531 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17532 
      oprot.writeDouble(self.sellingPrice)
17533 
      oprot.writeFieldEnd()
17534 
    if self.isFba is not None:
17535 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17536 
      oprot.writeBool(self.isFba)
17537 
      oprot.writeFieldEnd()
17538 
    if self.isNonFba is not None:
17539 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17540 
      oprot.writeBool(self.isNonFba)
17541 
      oprot.writeFieldEnd()
17542 
    if self.isInventoryOverride is not None:
17543 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17544 
      oprot.writeBool(self.isInventoryOverride)
17545 
      oprot.writeFieldEnd()
7367 kshitij.so 17546 
    if self.handlingTime is not None:
17547 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17548 
      oprot.writeI64(self.handlingTime)
17549 
      oprot.writeFieldEnd()
17550 
    if self.isCustomTime is not None:
17551 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17552 
      oprot.writeBool(self.isCustomTime)
17553 
      oprot.writeFieldEnd()
7281 kshitij.so 17554 
    oprot.writeFieldStop()
17555 
    oprot.writeStructEnd()
17556 
 
17557 
  def validate(self):
17558 
    return
17559 
 
17560 
 
17561 
  def __repr__(self):
17562 
    L = ['%s=%r' % (key, value)
17563 
      for key, value in self.__dict__.iteritems()]
17564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17565 
 
17566 
  def __eq__(self, other):
17567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17568 
 
17569 
  def __ne__(self, other):
17570 
    return not (self == other)
17571 
 
17572 
class updateAmazonItemDetails_result:
17573 
 
17574 
  thrift_spec = (
17575 
  )
17576 
 
17577 
  def read(self, iprot):
17578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17580 
      return
17581 
    iprot.readStructBegin()
17582 
    while True:
17583 
      (fname, ftype, fid) = iprot.readFieldBegin()
17584 
      if ftype == TType.STOP:
17585 
        break
17586 
      else:
17587 
        iprot.skip(ftype)
17588 
      iprot.readFieldEnd()
17589 
    iprot.readStructEnd()
17590 
 
17591 
  def write(self, oprot):
17592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17594 
      return
17595 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17596 
    oprot.writeFieldStop()
17597 
    oprot.writeStructEnd()
17598 
 
17599 
  def validate(self):
17600 
    return
17601 
 
17602 
 
17603 
  def __repr__(self):
17604 
    L = ['%s=%r' % (key, value)
17605 
      for key, value in self.__dict__.iteritems()]
17606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17607 
 
17608 
  def __eq__(self, other):
17609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17610 
 
17611 
  def __ne__(self, other):
17612 
    return not (self == other)
17613 
 
17614 
class addAmazonItem_args:
17615 
  """
17616 
  Attributes:
17617 
   - amazonlisted
17618 
  """
17619 
 
17620 
  thrift_spec = (
17621 
    None, # 0
17622 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17623 
  )
17624 
 
17625 
  def __init__(self, amazonlisted=None,):
17626 
    self.amazonlisted = amazonlisted
17627 
 
17628 
  def read(self, iprot):
17629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17631 
      return
17632 
    iprot.readStructBegin()
17633 
    while True:
17634 
      (fname, ftype, fid) = iprot.readFieldBegin()
17635 
      if ftype == TType.STOP:
17636 
        break
17637 
      if fid == 1:
17638 
        if ftype == TType.STRUCT:
17639 
          self.amazonlisted = Amazonlisted()
17640 
          self.amazonlisted.read(iprot)
17641 
        else:
17642 
          iprot.skip(ftype)
17643 
      else:
17644 
        iprot.skip(ftype)
17645 
      iprot.readFieldEnd()
17646 
    iprot.readStructEnd()
17647 
 
17648 
  def write(self, oprot):
17649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17651 
      return
17652 
    oprot.writeStructBegin('addAmazonItem_args')
17653 
    if self.amazonlisted is not None:
17654 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17655 
      self.amazonlisted.write(oprot)
17656 
      oprot.writeFieldEnd()
17657 
    oprot.writeFieldStop()
17658 
    oprot.writeStructEnd()
17659 
 
17660 
  def validate(self):
17661 
    return
17662 
 
17663 
 
17664 
  def __repr__(self):
17665 
    L = ['%s=%r' % (key, value)
17666 
      for key, value in self.__dict__.iteritems()]
17667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17668 
 
17669 
  def __eq__(self, other):
17670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17671 
 
17672 
  def __ne__(self, other):
17673 
    return not (self == other)
17674 
 
17675 
class addAmazonItem_result:
17676 
 
17677 
  thrift_spec = (
17678 
  )
17679 
 
17680 
  def read(self, iprot):
17681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17683 
      return
17684 
    iprot.readStructBegin()
17685 
    while True:
17686 
      (fname, ftype, fid) = iprot.readFieldBegin()
17687 
      if ftype == TType.STOP:
17688 
        break
17689 
      else:
17690 
        iprot.skip(ftype)
17691 
      iprot.readFieldEnd()
17692 
    iprot.readStructEnd()
17693 
 
17694 
  def write(self, oprot):
17695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17697 
      return
17698 
    oprot.writeStructBegin('addAmazonItem_result')
17699 
    oprot.writeFieldStop()
17700 
    oprot.writeStructEnd()
17701 
 
17702 
  def validate(self):
17703 
    return
17704 
 
17705 
 
17706 
  def __repr__(self):
17707 
    L = ['%s=%r' % (key, value)
17708 
      for key, value in self.__dict__.iteritems()]
17709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17710 
 
17711 
  def __eq__(self, other):
17712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17713 
 
17714 
  def __ne__(self, other):
17715 
    return not (self == other)
7291 vikram.rag 17716 
 
17717 
class getAsinItems_args:
17718 
 
17719 
  thrift_spec = (
17720 
  )
17721 
 
17722 
  def read(self, iprot):
17723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17725 
      return
17726 
    iprot.readStructBegin()
17727 
    while True:
17728 
      (fname, ftype, fid) = iprot.readFieldBegin()
17729 
      if ftype == TType.STOP:
17730 
        break
17731 
      else:
17732 
        iprot.skip(ftype)
17733 
      iprot.readFieldEnd()
17734 
    iprot.readStructEnd()
17735 
 
17736 
  def write(self, oprot):
17737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17739 
      return
17740 
    oprot.writeStructBegin('getAsinItems_args')
17741 
    oprot.writeFieldStop()
17742 
    oprot.writeStructEnd()
17743 
 
17744 
  def validate(self):
17745 
    return
17746 
 
17747 
 
17748 
  def __repr__(self):
17749 
    L = ['%s=%r' % (key, value)
17750 
      for key, value in self.__dict__.iteritems()]
17751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17752 
 
17753 
  def __eq__(self, other):
17754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17755 
 
17756 
  def __ne__(self, other):
17757 
    return not (self == other)
17758 
 
17759 
class getAsinItems_result:
17760 
  """
17761 
  Attributes:
17762 
   - success
17763 
  """
17764 
 
17765 
  thrift_spec = (
17766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17767 
  )
17768 
 
17769 
  def __init__(self, success=None,):
17770 
    self.success = success
17771 
 
17772 
  def read(self, iprot):
17773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17775 
      return
17776 
    iprot.readStructBegin()
17777 
    while True:
17778 
      (fname, ftype, fid) = iprot.readFieldBegin()
17779 
      if ftype == TType.STOP:
17780 
        break
17781 
      if fid == 0:
17782 
        if ftype == TType.LIST:
17783 
          self.success = []
7438 amit.gupta 17784 
          (_etype347, _size344) = iprot.readListBegin()
17785 
          for _i348 in xrange(_size344):
17786 
            _elem349 = Item()
17787 
            _elem349.read(iprot)
17788 
            self.success.append(_elem349)
7291 vikram.rag 17789 
          iprot.readListEnd()
17790 
        else:
17791 
          iprot.skip(ftype)
17792 
      else:
17793 
        iprot.skip(ftype)
17794 
      iprot.readFieldEnd()
17795 
    iprot.readStructEnd()
17796 
 
17797 
  def write(self, oprot):
17798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17800 
      return
17801 
    oprot.writeStructBegin('getAsinItems_result')
17802 
    if self.success is not None:
17803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17805 
      for iter350 in self.success:
17806 
        iter350.write(oprot)
7291 vikram.rag 17807 
      oprot.writeListEnd()
17808 
      oprot.writeFieldEnd()
17809 
    oprot.writeFieldStop()
17810 
    oprot.writeStructEnd()
17811 
 
17812 
  def validate(self):
17813 
    return
17814 
 
17815 
 
17816 
  def __repr__(self):
17817 
    L = ['%s=%r' % (key, value)
17818 
      for key, value in self.__dict__.iteritems()]
17819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17820 
 
17821 
  def __eq__(self, other):
17822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17823 
 
17824 
  def __ne__(self, other):
17825 
    return not (self == other)
17826 
 
17827 
class getAllFbaListedItems_args:
17828 
 
17829 
  thrift_spec = (
17830 
  )
17831 
 
17832 
  def read(self, iprot):
17833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17835 
      return
17836 
    iprot.readStructBegin()
17837 
    while True:
17838 
      (fname, ftype, fid) = iprot.readFieldBegin()
17839 
      if ftype == TType.STOP:
17840 
        break
17841 
      else:
17842 
        iprot.skip(ftype)
17843 
      iprot.readFieldEnd()
17844 
    iprot.readStructEnd()
17845 
 
17846 
  def write(self, oprot):
17847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17849 
      return
17850 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17851 
    oprot.writeFieldStop()
17852 
    oprot.writeStructEnd()
17853 
 
17854 
  def validate(self):
17855 
    return
17856 
 
17857 
 
17858 
  def __repr__(self):
17859 
    L = ['%s=%r' % (key, value)
17860 
      for key, value in self.__dict__.iteritems()]
17861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17862 
 
17863 
  def __eq__(self, other):
17864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17865 
 
17866 
  def __ne__(self, other):
17867 
    return not (self == other)
17868 
 
17869 
class getAllFbaListedItems_result:
17870 
  """
17871 
  Attributes:
17872 
   - success
17873 
  """
17874 
 
17875 
  thrift_spec = (
17876 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17877 
  )
17878 
 
17879 
  def __init__(self, success=None,):
17880 
    self.success = success
17881 
 
17882 
  def read(self, iprot):
17883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17885 
      return
17886 
    iprot.readStructBegin()
17887 
    while True:
17888 
      (fname, ftype, fid) = iprot.readFieldBegin()
17889 
      if ftype == TType.STOP:
17890 
        break
17891 
      if fid == 0:
17892 
        if ftype == TType.LIST:
17893 
          self.success = []
7438 amit.gupta 17894 
          (_etype354, _size351) = iprot.readListBegin()
17895 
          for _i355 in xrange(_size351):
17896 
            _elem356 = Amazonlisted()
17897 
            _elem356.read(iprot)
17898 
            self.success.append(_elem356)
7291 vikram.rag 17899 
          iprot.readListEnd()
17900 
        else:
17901 
          iprot.skip(ftype)
17902 
      else:
17903 
        iprot.skip(ftype)
17904 
      iprot.readFieldEnd()
17905 
    iprot.readStructEnd()
17906 
 
17907 
  def write(self, oprot):
17908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17910 
      return
17911 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17912 
    if self.success is not None:
17913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17914 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17915 
      for iter357 in self.success:
17916 
        iter357.write(oprot)
7291 vikram.rag 17917 
      oprot.writeListEnd()
17918 
      oprot.writeFieldEnd()
17919 
    oprot.writeFieldStop()
17920 
    oprot.writeStructEnd()
17921 
 
17922 
  def validate(self):
17923 
    return
17924 
 
17925 
 
17926 
  def __repr__(self):
17927 
    L = ['%s=%r' % (key, value)
17928 
      for key, value in self.__dict__.iteritems()]
17929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17930 
 
17931 
  def __eq__(self, other):
17932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17933 
 
17934 
  def __ne__(self, other):
17935 
    return not (self == other)
17936 
 
17937 
class getAllNonFbaListedItems_args:
17938 
 
17939 
  thrift_spec = (
17940 
  )
17941 
 
17942 
  def read(self, iprot):
17943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17945 
      return
17946 
    iprot.readStructBegin()
17947 
    while True:
17948 
      (fname, ftype, fid) = iprot.readFieldBegin()
17949 
      if ftype == TType.STOP:
17950 
        break
17951 
      else:
17952 
        iprot.skip(ftype)
17953 
      iprot.readFieldEnd()
17954 
    iprot.readStructEnd()
17955 
 
17956 
  def write(self, oprot):
17957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17959 
      return
17960 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17961 
    oprot.writeFieldStop()
17962 
    oprot.writeStructEnd()
17963 
 
17964 
  def validate(self):
17965 
    return
17966 
 
17967 
 
17968 
  def __repr__(self):
17969 
    L = ['%s=%r' % (key, value)
17970 
      for key, value in self.__dict__.iteritems()]
17971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17972 
 
17973 
  def __eq__(self, other):
17974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17975 
 
17976 
  def __ne__(self, other):
17977 
    return not (self == other)
17978 
 
17979 
class getAllNonFbaListedItems_result:
17980 
  """
17981 
  Attributes:
17982 
   - success
17983 
  """
17984 
 
17985 
  thrift_spec = (
17986 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17987 
  )
17988 
 
17989 
  def __init__(self, success=None,):
17990 
    self.success = success
17991 
 
17992 
  def read(self, iprot):
17993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17995 
      return
17996 
    iprot.readStructBegin()
17997 
    while True:
17998 
      (fname, ftype, fid) = iprot.readFieldBegin()
17999 
      if ftype == TType.STOP:
18000 
        break
18001 
      if fid == 0:
18002 
        if ftype == TType.LIST:
18003 
          self.success = []
7438 amit.gupta 18004 
          (_etype361, _size358) = iprot.readListBegin()
18005 
          for _i362 in xrange(_size358):
18006 
            _elem363 = Amazonlisted()
18007 
            _elem363.read(iprot)
18008 
            self.success.append(_elem363)
7291 vikram.rag 18009 
          iprot.readListEnd()
18010 
        else:
18011 
          iprot.skip(ftype)
18012 
      else:
18013 
        iprot.skip(ftype)
18014 
      iprot.readFieldEnd()
18015 
    iprot.readStructEnd()
18016 
 
18017 
  def write(self, oprot):
18018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18020 
      return
18021 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
18022 
    if self.success is not None:
18023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18025 
      for iter364 in self.success:
18026 
        iter364.write(oprot)
7291 vikram.rag 18027 
      oprot.writeListEnd()
18028 
      oprot.writeFieldEnd()
18029 
    oprot.writeFieldStop()
18030 
    oprot.writeStructEnd()
18031 
 
18032 
  def validate(self):
18033 
    return
18034 
 
18035 
 
18036 
  def __repr__(self):
18037 
    L = ['%s=%r' % (key, value)
18038 
      for key, value in self.__dict__.iteritems()]
18039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18040 
 
18041 
  def __eq__(self, other):
18042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18043 
 
18044 
  def __ne__(self, other):
18045 
    return not (self == other)
7460 kshitij.so 18046 
 
18047 
class updateItemInventory_args:
18048 
  """
18049 
  Attributes:
18050 
   - itemId
18051 
   - holdInventory
18052 
   - defaultInventory
18053 
  """
18054 
 
18055 
  thrift_spec = (
18056 
    None, # 0
18057 
    (1, TType.I64, 'itemId', None, None, ), # 1
18058 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
18059 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
18060 
  )
18061 
 
18062 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
18063 
    self.itemId = itemId
18064 
    self.holdInventory = holdInventory
18065 
    self.defaultInventory = defaultInventory
18066 
 
18067 
  def read(self, iprot):
18068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18070 
      return
18071 
    iprot.readStructBegin()
18072 
    while True:
18073 
      (fname, ftype, fid) = iprot.readFieldBegin()
18074 
      if ftype == TType.STOP:
18075 
        break
18076 
      if fid == 1:
18077 
        if ftype == TType.I64:
18078 
          self.itemId = iprot.readI64();
18079 
        else:
18080 
          iprot.skip(ftype)
18081 
      elif fid == 2:
18082 
        if ftype == TType.I64:
18083 
          self.holdInventory = iprot.readI64();
18084 
        else:
18085 
          iprot.skip(ftype)
18086 
      elif fid == 3:
18087 
        if ftype == TType.I64:
18088 
          self.defaultInventory = iprot.readI64();
18089 
        else:
18090 
          iprot.skip(ftype)
18091 
      else:
18092 
        iprot.skip(ftype)
18093 
      iprot.readFieldEnd()
18094 
    iprot.readStructEnd()
18095 
 
18096 
  def write(self, oprot):
18097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18099 
      return
18100 
    oprot.writeStructBegin('updateItemInventory_args')
18101 
    if self.itemId is not None:
18102 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18103 
      oprot.writeI64(self.itemId)
18104 
      oprot.writeFieldEnd()
18105 
    if self.holdInventory is not None:
18106 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
18107 
      oprot.writeI64(self.holdInventory)
18108 
      oprot.writeFieldEnd()
18109 
    if self.defaultInventory is not None:
18110 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
18111 
      oprot.writeI64(self.defaultInventory)
18112 
      oprot.writeFieldEnd()
18113 
    oprot.writeFieldStop()
18114 
    oprot.writeStructEnd()
18115 
 
18116 
  def validate(self):
18117 
    return
18118 
 
18119 
 
18120 
  def __repr__(self):
18121 
    L = ['%s=%r' % (key, value)
18122 
      for key, value in self.__dict__.iteritems()]
18123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18124 
 
18125 
  def __eq__(self, other):
18126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18127 
 
18128 
  def __ne__(self, other):
18129 
    return not (self == other)
18130 
 
18131 
class updateItemInventory_result:
18132 
  """
18133 
  Attributes:
18134 
   - success
18135 
  """
18136 
 
18137 
  thrift_spec = (
18138 
    (0, TType.BOOL, 'success', None, None, ), # 0
18139 
  )
18140 
 
18141 
  def __init__(self, success=None,):
18142 
    self.success = success
18143 
 
18144 
  def read(self, iprot):
18145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18147 
      return
18148 
    iprot.readStructBegin()
18149 
    while True:
18150 
      (fname, ftype, fid) = iprot.readFieldBegin()
18151 
      if ftype == TType.STOP:
18152 
        break
18153 
      if fid == 0:
18154 
        if ftype == TType.BOOL:
18155 
          self.success = iprot.readBool();
18156 
        else:
18157 
          iprot.skip(ftype)
18158 
      else:
18159 
        iprot.skip(ftype)
18160 
      iprot.readFieldEnd()
18161 
    iprot.readStructEnd()
18162 
 
18163 
  def write(self, oprot):
18164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18166 
      return
18167 
    oprot.writeStructBegin('updateItemInventory_result')
18168 
    if self.success is not None:
18169 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18170 
      oprot.writeBool(self.success)
18171 
      oprot.writeFieldEnd()
18172 
    oprot.writeFieldStop()
18173 
    oprot.writeStructEnd()
18174 
 
18175 
  def validate(self):
18176 
    return
18177 
 
18178 
 
18179 
  def __repr__(self):
18180 
    L = ['%s=%r' % (key, value)
18181 
      for key, value in self.__dict__.iteritems()]
18182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18183 
 
18184 
  def __eq__(self, other):
18185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18186 
 
18187 
  def __ne__(self, other):
18188 
    return not (self == other)
7770 kshitij.so 18189 
 
18190 
class updateTimestampForAmazonFeeds_args:
18191 
  """
18192 
  Attributes:
18193 
   - type
18194 
   - sku
18195 
   - timestamp
18196 
  """
18197 
 
18198 
  thrift_spec = (
18199 
    None, # 0
18200 
    (1, TType.STRING, 'type', None, None, ), # 1
18201 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18202 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18203 
  )
18204 
 
18205 
  def __init__(self, type=None, sku=None, timestamp=None,):
18206 
    self.type = type
18207 
    self.sku = sku
18208 
    self.timestamp = timestamp
18209 
 
18210 
  def read(self, iprot):
18211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18213 
      return
18214 
    iprot.readStructBegin()
18215 
    while True:
18216 
      (fname, ftype, fid) = iprot.readFieldBegin()
18217 
      if ftype == TType.STOP:
18218 
        break
18219 
      if fid == 1:
18220 
        if ftype == TType.STRING:
18221 
          self.type = iprot.readString();
18222 
        else:
18223 
          iprot.skip(ftype)
18224 
      elif fid == 2:
18225 
        if ftype == TType.LIST:
18226 
          self.sku = []
18227 
          (_etype368, _size365) = iprot.readListBegin()
18228 
          for _i369 in xrange(_size365):
18229 
            _elem370 = iprot.readI64();
18230 
            self.sku.append(_elem370)
18231 
          iprot.readListEnd()
18232 
        else:
18233 
          iprot.skip(ftype)
18234 
      elif fid == 3:
18235 
        if ftype == TType.I64:
18236 
          self.timestamp = iprot.readI64();
18237 
        else:
18238 
          iprot.skip(ftype)
18239 
      else:
18240 
        iprot.skip(ftype)
18241 
      iprot.readFieldEnd()
18242 
    iprot.readStructEnd()
18243 
 
18244 
  def write(self, oprot):
18245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18247 
      return
18248 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18249 
    if self.type is not None:
18250 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18251 
      oprot.writeString(self.type)
18252 
      oprot.writeFieldEnd()
18253 
    if self.sku is not None:
18254 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18255 
      oprot.writeListBegin(TType.I64, len(self.sku))
18256 
      for iter371 in self.sku:
18257 
        oprot.writeI64(iter371)
18258 
      oprot.writeListEnd()
18259 
      oprot.writeFieldEnd()
18260 
    if self.timestamp is not None:
18261 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18262 
      oprot.writeI64(self.timestamp)
18263 
      oprot.writeFieldEnd()
18264 
    oprot.writeFieldStop()
18265 
    oprot.writeStructEnd()
18266 
 
18267 
  def validate(self):
18268 
    return
18269 
 
18270 
 
18271 
  def __repr__(self):
18272 
    L = ['%s=%r' % (key, value)
18273 
      for key, value in self.__dict__.iteritems()]
18274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18275 
 
18276 
  def __eq__(self, other):
18277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18278 
 
18279 
  def __ne__(self, other):
18280 
    return not (self == other)
18281 
 
18282 
class updateTimestampForAmazonFeeds_result:
18283 
  """
18284 
  Attributes:
18285 
   - success
18286 
  """
18287 
 
18288 
  thrift_spec = (
18289 
    (0, TType.BOOL, 'success', None, None, ), # 0
18290 
  )
18291 
 
18292 
  def __init__(self, success=None,):
18293 
    self.success = success
18294 
 
18295 
  def read(self, iprot):
18296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18298 
      return
18299 
    iprot.readStructBegin()
18300 
    while True:
18301 
      (fname, ftype, fid) = iprot.readFieldBegin()
18302 
      if ftype == TType.STOP:
18303 
        break
18304 
      if fid == 0:
18305 
        if ftype == TType.BOOL:
18306 
          self.success = iprot.readBool();
18307 
        else:
18308 
          iprot.skip(ftype)
18309 
      else:
18310 
        iprot.skip(ftype)
18311 
      iprot.readFieldEnd()
18312 
    iprot.readStructEnd()
18313 
 
18314 
  def write(self, oprot):
18315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18317 
      return
18318 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18319 
    if self.success is not None:
18320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18321 
      oprot.writeBool(self.success)
18322 
      oprot.writeFieldEnd()
18323 
    oprot.writeFieldStop()
18324 
    oprot.writeStructEnd()
18325 
 
18326 
  def validate(self):
18327 
    return
18328 
 
18329 
 
18330 
  def __repr__(self):
18331 
    L = ['%s=%r' % (key, value)
18332 
      for key, value in self.__dict__.iteritems()]
18333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18334 
 
18335 
  def __eq__(self, other):
18336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18337 
 
18338 
  def __ne__(self, other):
18339 
    return not (self == other)
7897 amar.kumar 18340 
 
18341 
class getAllParentCategories_args:
18342 
 
18343 
  thrift_spec = (
18344 
  )
18345 
 
18346 
  def read(self, iprot):
18347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18349 
      return
18350 
    iprot.readStructBegin()
18351 
    while True:
18352 
      (fname, ftype, fid) = iprot.readFieldBegin()
18353 
      if ftype == TType.STOP:
18354 
        break
18355 
      else:
18356 
        iprot.skip(ftype)
18357 
      iprot.readFieldEnd()
18358 
    iprot.readStructEnd()
18359 
 
18360 
  def write(self, oprot):
18361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18363 
      return
18364 
    oprot.writeStructBegin('getAllParentCategories_args')
18365 
    oprot.writeFieldStop()
18366 
    oprot.writeStructEnd()
18367 
 
18368 
  def validate(self):
18369 
    return
18370 
 
18371 
 
18372 
  def __repr__(self):
18373 
    L = ['%s=%r' % (key, value)
18374 
      for key, value in self.__dict__.iteritems()]
18375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18376 
 
18377 
  def __eq__(self, other):
18378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18379 
 
18380 
  def __ne__(self, other):
18381 
    return not (self == other)
18382 
 
18383 
class getAllParentCategories_result:
18384 
  """
18385 
  Attributes:
18386 
   - success
18387 
  """
18388 
 
18389 
  thrift_spec = (
18390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
18391 
  )
18392 
 
18393 
  def __init__(self, success=None,):
18394 
    self.success = success
18395 
 
18396 
  def read(self, iprot):
18397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18399 
      return
18400 
    iprot.readStructBegin()
18401 
    while True:
18402 
      (fname, ftype, fid) = iprot.readFieldBegin()
18403 
      if ftype == TType.STOP:
18404 
        break
18405 
      if fid == 0:
18406 
        if ftype == TType.LIST:
18407 
          self.success = []
18408 
          (_etype375, _size372) = iprot.readListBegin()
18409 
          for _i376 in xrange(_size372):
18410 
            _elem377 = Category()
18411 
            _elem377.read(iprot)
18412 
            self.success.append(_elem377)
18413 
          iprot.readListEnd()
18414 
        else:
18415 
          iprot.skip(ftype)
18416 
      else:
18417 
        iprot.skip(ftype)
18418 
      iprot.readFieldEnd()
18419 
    iprot.readStructEnd()
18420 
 
18421 
  def write(self, oprot):
18422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18424 
      return
18425 
    oprot.writeStructBegin('getAllParentCategories_result')
18426 
    if self.success is not None:
18427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18428 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18429 
      for iter378 in self.success:
18430 
        iter378.write(oprot)
18431 
      oprot.writeListEnd()
18432 
      oprot.writeFieldEnd()
18433 
    oprot.writeFieldStop()
18434 
    oprot.writeStructEnd()
18435 
 
18436 
  def validate(self):
18437 
    return
18438 
 
18439 
 
18440 
  def __repr__(self):
18441 
    L = ['%s=%r' % (key, value)
18442 
      for key, value in self.__dict__.iteritems()]
18443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18444 
 
18445 
  def __eq__(self, other):
18446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18447 
 
18448 
  def __ne__(self, other):
18449 
    return not (self == other)
7977 kshitij.so 18450 
 
18451 
class addPageViewEvent_args:
18452 
  """
18453 
  Attributes:
18454 
   - pageViewEvents
18455 
  """
18456 
 
18457 
  thrift_spec = (
18458 
    None, # 0
18459 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
18460 
  )
18461 
 
18462 
  def __init__(self, pageViewEvents=None,):
18463 
    self.pageViewEvents = pageViewEvents
18464 
 
18465 
  def read(self, iprot):
18466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18468 
      return
18469 
    iprot.readStructBegin()
18470 
    while True:
18471 
      (fname, ftype, fid) = iprot.readFieldBegin()
18472 
      if ftype == TType.STOP:
18473 
        break
18474 
      if fid == 1:
18475 
        if ftype == TType.STRUCT:
18476 
          self.pageViewEvents = PageViewEvents()
18477 
          self.pageViewEvents.read(iprot)
18478 
        else:
18479 
          iprot.skip(ftype)
18480 
      else:
18481 
        iprot.skip(ftype)
18482 
      iprot.readFieldEnd()
18483 
    iprot.readStructEnd()
18484 
 
18485 
  def write(self, oprot):
18486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18488 
      return
18489 
    oprot.writeStructBegin('addPageViewEvent_args')
18490 
    if self.pageViewEvents is not None:
18491 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
18492 
      self.pageViewEvents.write(oprot)
18493 
      oprot.writeFieldEnd()
18494 
    oprot.writeFieldStop()
18495 
    oprot.writeStructEnd()
18496 
 
18497 
  def validate(self):
18498 
    return
18499 
 
18500 
 
18501 
  def __repr__(self):
18502 
    L = ['%s=%r' % (key, value)
18503 
      for key, value in self.__dict__.iteritems()]
18504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18505 
 
18506 
  def __eq__(self, other):
18507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18508 
 
18509 
  def __ne__(self, other):
18510 
    return not (self == other)
18511 
 
18512 
class addPageViewEvent_result:
18513 
 
18514 
  thrift_spec = (
18515 
  )
18516 
 
18517 
  def read(self, iprot):
18518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18520 
      return
18521 
    iprot.readStructBegin()
18522 
    while True:
18523 
      (fname, ftype, fid) = iprot.readFieldBegin()
18524 
      if ftype == TType.STOP:
18525 
        break
18526 
      else:
18527 
        iprot.skip(ftype)
18528 
      iprot.readFieldEnd()
18529 
    iprot.readStructEnd()
18530 
 
18531 
  def write(self, oprot):
18532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18534 
      return
18535 
    oprot.writeStructBegin('addPageViewEvent_result')
18536 
    oprot.writeFieldStop()
18537 
    oprot.writeStructEnd()
18538 
 
18539 
  def validate(self):
18540 
    return
18541 
 
18542 
 
18543 
  def __repr__(self):
18544 
    L = ['%s=%r' % (key, value)
18545 
      for key, value in self.__dict__.iteritems()]
18546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18547 
 
18548 
  def __eq__(self, other):
18549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18550 
 
18551 
  def __ne__(self, other):
18552 
    return not (self == other)
18553 
 
18554 
class addCartEvent_args:
18555 
  """
18556 
  Attributes:
18557 
   - cartEvents
18558 
  """
18559 
 
18560 
  thrift_spec = (
18561 
    None, # 0
18562 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
18563 
  )
18564 
 
18565 
  def __init__(self, cartEvents=None,):
18566 
    self.cartEvents = cartEvents
18567 
 
18568 
  def read(self, iprot):
18569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18571 
      return
18572 
    iprot.readStructBegin()
18573 
    while True:
18574 
      (fname, ftype, fid) = iprot.readFieldBegin()
18575 
      if ftype == TType.STOP:
18576 
        break
18577 
      if fid == 1:
18578 
        if ftype == TType.STRUCT:
18579 
          self.cartEvents = CartEvents()
18580 
          self.cartEvents.read(iprot)
18581 
        else:
18582 
          iprot.skip(ftype)
18583 
      else:
18584 
        iprot.skip(ftype)
18585 
      iprot.readFieldEnd()
18586 
    iprot.readStructEnd()
18587 
 
18588 
  def write(self, oprot):
18589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18591 
      return
18592 
    oprot.writeStructBegin('addCartEvent_args')
18593 
    if self.cartEvents is not None:
18594 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
18595 
      self.cartEvents.write(oprot)
18596 
      oprot.writeFieldEnd()
18597 
    oprot.writeFieldStop()
18598 
    oprot.writeStructEnd()
18599 
 
18600 
  def validate(self):
18601 
    return
18602 
 
18603 
 
18604 
  def __repr__(self):
18605 
    L = ['%s=%r' % (key, value)
18606 
      for key, value in self.__dict__.iteritems()]
18607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18608 
 
18609 
  def __eq__(self, other):
18610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18611 
 
18612 
  def __ne__(self, other):
18613 
    return not (self == other)
18614 
 
18615 
class addCartEvent_result:
18616 
 
18617 
  thrift_spec = (
18618 
  )
18619 
 
18620 
  def read(self, iprot):
18621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18623 
      return
18624 
    iprot.readStructBegin()
18625 
    while True:
18626 
      (fname, ftype, fid) = iprot.readFieldBegin()
18627 
      if ftype == TType.STOP:
18628 
        break
18629 
      else:
18630 
        iprot.skip(ftype)
18631 
      iprot.readFieldEnd()
18632 
    iprot.readStructEnd()
18633 
 
18634 
  def write(self, oprot):
18635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18637 
      return
18638 
    oprot.writeStructBegin('addCartEvent_result')
18639 
    oprot.writeFieldStop()
18640 
    oprot.writeStructEnd()
18641 
 
18642 
  def validate(self):
18643 
    return
18644 
 
18645 
 
18646 
  def __repr__(self):
18647 
    L = ['%s=%r' % (key, value)
18648 
      for key, value in self.__dict__.iteritems()]
18649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18650 
 
18651 
  def __eq__(self, other):
18652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18653 
 
18654 
  def __ne__(self, other):
18655 
    return not (self == other)