Subversion Repositories SmartDukaan

Rev

Rev 8139 | Rev 8182 | 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 
 
8168 kshitij.so 720 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 721 
    """
722 
    Parameters:
8168 kshitij.so 723 
     - amazonlisted
7281 kshitij.so 724 
    """
725 
    pass
726 
 
727 
  def addAmazonItem(self, amazonlisted):
728 
    """
729 
    Parameters:
730 
     - amazonlisted
731 
    """
732 
    pass
733 
 
7291 vikram.rag 734 
  def getAsinItems(self, ):
735 
    pass
7281 kshitij.so 736 
 
7291 vikram.rag 737 
  def getAllFbaListedItems(self, ):
738 
    pass
739 
 
740 
  def getAllNonFbaListedItems(self, ):
741 
    pass
742 
 
7460 kshitij.so 743 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
     - holdInventory
748 
     - defaultInventory
749 
    """
750 
    pass
7291 vikram.rag 751 
 
7770 kshitij.so 752 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
753 
    """
754 
    Parameters:
755 
     - type
756 
     - sku
757 
     - timestamp
758 
    """
759 
    pass
7460 kshitij.so 760 
 
7897 amar.kumar 761 
  def getAllParentCategories(self, ):
762 
    pass
7770 kshitij.so 763 
 
7977 kshitij.so 764 
  def addPageViewEvent(self, pageViewEvents):
765 
    """
766 
    Parameters:
767 
     - pageViewEvents
768 
    """
769 
    pass
7897 amar.kumar 770 
 
7977 kshitij.so 771 
  def addCartEvent(self, cartEvents):
772 
    """
773 
    Parameters:
774 
     - cartEvents
775 
    """
776 
    pass
777 
 
8139 kshitij.so 778 
  def getAmazonListedItems(self, offset, limit):
779 
    """
780 
    Parameters:
781 
     - offset
782 
     - limit
783 
    """
784 
    pass
7977 kshitij.so 785 
 
8168 kshitij.so 786 
  def updateAmazonAttributesInBulk(self, amazonlisted):
787 
    """
788 
    Parameters:
789 
     - amazonlisted
790 
    """
791 
    pass
8139 kshitij.so 792 
 
8168 kshitij.so 793 
 
5944 mandeep.dh 794 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
795 
  def __init__(self, iprot, oprot=None):
796 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
797 
 
798 
  def addItem(self, item):
799 
    """
800 
    Availability and inventory attributes
801 
 
802 
    Parameters:
803 
     - item
804 
    """
805 
    self.send_addItem(item)
806 
    return self.recv_addItem()
807 
 
808 
  def send_addItem(self, item):
809 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
810 
    args = addItem_args()
811 
    args.item = item
812 
    args.write(self._oprot)
813 
    self._oprot.writeMessageEnd()
814 
    self._oprot.trans.flush()
815 
 
816 
  def recv_addItem(self, ):
817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
818 
    if mtype == TMessageType.EXCEPTION:
819 
      x = TApplicationException()
820 
      x.read(self._iprot)
821 
      self._iprot.readMessageEnd()
822 
      raise x
823 
    result = addItem_result()
824 
    result.read(self._iprot)
825 
    self._iprot.readMessageEnd()
826 
    if result.success is not None:
827 
      return result.success
828 
    if result.cex is not None:
829 
      raise result.cex
830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
831 
 
832 
  def updateItem(self, item):
833 
    """
834 
    Parameters:
835 
     - item
836 
    """
837 
    self.send_updateItem(item)
838 
    return self.recv_updateItem()
839 
 
840 
  def send_updateItem(self, item):
841 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
842 
    args = updateItem_args()
843 
    args.item = item
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_updateItem(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = updateItem_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
858 
    if result.success is not None:
859 
      return result.success
860 
    if result.cex is not None:
861 
      raise result.cex
862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
863 
 
864 
  def isActive(self, itemId):
865 
    """
866 
    Checks if the item given to the corresponding itemId is active. If it's active,
867 
    whether it's risky and if it's risky, its inventory position.
868 
 
869 
    Parameters:
870 
     - itemId
871 
    """
872 
    self.send_isActive(itemId)
873 
    return self.recv_isActive()
874 
 
875 
  def send_isActive(self, itemId):
876 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
877 
    args = isActive_args()
878 
    args.itemId = itemId
879 
    args.write(self._oprot)
880 
    self._oprot.writeMessageEnd()
881 
    self._oprot.trans.flush()
882 
 
883 
  def recv_isActive(self, ):
884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
885 
    if mtype == TMessageType.EXCEPTION:
886 
      x = TApplicationException()
887 
      x.read(self._iprot)
888 
      self._iprot.readMessageEnd()
889 
      raise x
890 
    result = isActive_result()
891 
    result.read(self._iprot)
892 
    self._iprot.readMessageEnd()
893 
    if result.success is not None:
894 
      return result.success
895 
    if result.isex is not None:
896 
      raise result.isex
897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
898 
 
7438 amit.gupta 899 
  def getItemsStatus(self, itemIds):
900 
    """
901 
    Parameters:
902 
     - itemIds
903 
    """
904 
    self.send_getItemsStatus(itemIds)
905 
    return self.recv_getItemsStatus()
906 
 
907 
  def send_getItemsStatus(self, itemIds):
908 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
909 
    args = getItemsStatus_args()
910 
    args.itemIds = itemIds
911 
    args.write(self._oprot)
912 
    self._oprot.writeMessageEnd()
913 
    self._oprot.trans.flush()
914 
 
915 
  def recv_getItemsStatus(self, ):
916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
917 
    if mtype == TMessageType.EXCEPTION:
918 
      x = TApplicationException()
919 
      x.read(self._iprot)
920 
      self._iprot.readMessageEnd()
921 
      raise x
922 
    result = getItemsStatus_result()
923 
    result.read(self._iprot)
924 
    self._iprot.readMessageEnd()
925 
    if result.success is not None:
926 
      return result.success
927 
    if result.isex is not None:
928 
      raise result.isex
929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
930 
 
5944 mandeep.dh 931 
  def getItemStatusDescription(self, itemId):
932 
    """
933 
    Parameters:
934 
     - itemId
935 
    """
936 
    self.send_getItemStatusDescription(itemId)
937 
    return self.recv_getItemStatusDescription()
938 
 
939 
  def send_getItemStatusDescription(self, itemId):
940 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
941 
    args = getItemStatusDescription_args()
942 
    args.itemId = itemId
943 
    args.write(self._oprot)
944 
    self._oprot.writeMessageEnd()
945 
    self._oprot.trans.flush()
946 
 
947 
  def recv_getItemStatusDescription(self, ):
948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
949 
    if mtype == TMessageType.EXCEPTION:
950 
      x = TApplicationException()
951 
      x.read(self._iprot)
952 
      self._iprot.readMessageEnd()
953 
      raise x
954 
    result = getItemStatusDescription_result()
955 
    result.read(self._iprot)
956 
    self._iprot.readMessageEnd()
957 
    if result.success is not None:
958 
      return result.success
959 
    if result.isex is not None:
960 
      raise result.isex
961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
962 
 
963 
  def startItemOn(self, item_id, timestamp):
964 
    """
965 
    Parameters:
966 
     - item_id
967 
     - timestamp
968 
    """
969 
    self.send_startItemOn(item_id, timestamp)
970 
    self.recv_startItemOn()
971 
 
972 
  def send_startItemOn(self, item_id, timestamp):
973 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
974 
    args = startItemOn_args()
975 
    args.item_id = item_id
976 
    args.timestamp = timestamp
977 
    args.write(self._oprot)
978 
    self._oprot.writeMessageEnd()
979 
    self._oprot.trans.flush()
980 
 
981 
  def recv_startItemOn(self, ):
982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
983 
    if mtype == TMessageType.EXCEPTION:
984 
      x = TApplicationException()
985 
      x.read(self._iprot)
986 
      self._iprot.readMessageEnd()
987 
      raise x
988 
    result = startItemOn_result()
989 
    result.read(self._iprot)
990 
    self._iprot.readMessageEnd()
991 
    if result.cex is not None:
992 
      raise result.cex
993 
    return
994 
 
995 
  def retireItemOn(self, item_id, timestamp):
996 
    """
997 
    Parameters:
998 
     - item_id
999 
     - timestamp
1000 
    """
1001 
    self.send_retireItemOn(item_id, timestamp)
1002 
    self.recv_retireItemOn()
1003 
 
1004 
  def send_retireItemOn(self, item_id, timestamp):
1005 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1006 
    args = retireItemOn_args()
1007 
    args.item_id = item_id
1008 
    args.timestamp = timestamp
1009 
    args.write(self._oprot)
1010 
    self._oprot.writeMessageEnd()
1011 
    self._oprot.trans.flush()
1012 
 
1013 
  def recv_retireItemOn(self, ):
1014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1015 
    if mtype == TMessageType.EXCEPTION:
1016 
      x = TApplicationException()
1017 
      x.read(self._iprot)
1018 
      self._iprot.readMessageEnd()
1019 
      raise x
1020 
    result = retireItemOn_result()
1021 
    result.read(self._iprot)
1022 
    self._iprot.readMessageEnd()
1023 
    if result.cex is not None:
1024 
      raise result.cex
1025 
    return
1026 
 
1027 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1028 
    """
1029 
    Parameters:
1030 
     - item_id
1031 
     - timestamp
1032 
     - newstatus
1033 
    """
1034 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1035 
    self.recv_changeItemStatus()
1036 
 
1037 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1038 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1039 
    args = changeItemStatus_args()
1040 
    args.item_id = item_id
1041 
    args.timestamp = timestamp
1042 
    args.newstatus = newstatus
1043 
    args.write(self._oprot)
1044 
    self._oprot.writeMessageEnd()
1045 
    self._oprot.trans.flush()
1046 
 
1047 
  def recv_changeItemStatus(self, ):
1048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1049 
    if mtype == TMessageType.EXCEPTION:
1050 
      x = TApplicationException()
1051 
      x.read(self._iprot)
1052 
      self._iprot.readMessageEnd()
1053 
      raise x
1054 
    result = changeItemStatus_result()
1055 
    result.read(self._iprot)
1056 
    self._iprot.readMessageEnd()
1057 
    if result.cex is not None:
1058 
      raise result.cex
1059 
    return
1060 
 
1061 
  def getItem(self, item_id):
1062 
    """
1063 
    Parameters:
1064 
     - item_id
1065 
    """
1066 
    self.send_getItem(item_id)
1067 
    return self.recv_getItem()
1068 
 
1069 
  def send_getItem(self, item_id):
1070 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1071 
    args = getItem_args()
1072 
    args.item_id = item_id
1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
1077 
  def recv_getItem(self, ):
1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
1084 
    result = getItem_result()
1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
1087 
    if result.success is not None:
1088 
      return result.success
1089 
    if result.cex is not None:
1090 
      raise result.cex
1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1092 
 
1093 
  def getItemsByCatalogId(self, catalog_item_id):
1094 
    """
1095 
    Parameters:
1096 
     - catalog_item_id
1097 
    """
1098 
    self.send_getItemsByCatalogId(catalog_item_id)
1099 
    return self.recv_getItemsByCatalogId()
1100 
 
1101 
  def send_getItemsByCatalogId(self, catalog_item_id):
1102 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1103 
    args = getItemsByCatalogId_args()
1104 
    args.catalog_item_id = catalog_item_id
1105 
    args.write(self._oprot)
1106 
    self._oprot.writeMessageEnd()
1107 
    self._oprot.trans.flush()
1108 
 
1109 
  def recv_getItemsByCatalogId(self, ):
1110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1111 
    if mtype == TMessageType.EXCEPTION:
1112 
      x = TApplicationException()
1113 
      x.read(self._iprot)
1114 
      self._iprot.readMessageEnd()
1115 
      raise x
1116 
    result = getItemsByCatalogId_result()
1117 
    result.read(self._iprot)
1118 
    self._iprot.readMessageEnd()
1119 
    if result.success is not None:
1120 
      return result.success
1121 
    if result.cex is not None:
1122 
      raise result.cex
1123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1124 
 
1125 
  def getValidItemsByCatalogId(self, catalog_item_id):
1126 
    """
1127 
    Parameters:
1128 
     - catalog_item_id
1129 
    """
1130 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1131 
    return self.recv_getValidItemsByCatalogId()
1132 
 
1133 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1134 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1135 
    args = getValidItemsByCatalogId_args()
1136 
    args.catalog_item_id = catalog_item_id
1137 
    args.write(self._oprot)
1138 
    self._oprot.writeMessageEnd()
1139 
    self._oprot.trans.flush()
1140 
 
1141 
  def recv_getValidItemsByCatalogId(self, ):
1142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1143 
    if mtype == TMessageType.EXCEPTION:
1144 
      x = TApplicationException()
1145 
      x.read(self._iprot)
1146 
      self._iprot.readMessageEnd()
1147 
      raise x
1148 
    result = getValidItemsByCatalogId_result()
1149 
    result.read(self._iprot)
1150 
    self._iprot.readMessageEnd()
1151 
    if result.success is not None:
1152 
      return result.success
1153 
    if result.cex is not None:
1154 
      raise result.cex
1155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1156 
 
1157 
  def getAllItems(self, isActive):
1158 
    """
1159 
    Parameters:
1160 
     - isActive
1161 
    """
1162 
    self.send_getAllItems(isActive)
1163 
    return self.recv_getAllItems()
1164 
 
1165 
  def send_getAllItems(self, isActive):
1166 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1167 
    args = getAllItems_args()
1168 
    args.isActive = isActive
1169 
    args.write(self._oprot)
1170 
    self._oprot.writeMessageEnd()
1171 
    self._oprot.trans.flush()
1172 
 
1173 
  def recv_getAllItems(self, ):
1174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1175 
    if mtype == TMessageType.EXCEPTION:
1176 
      x = TApplicationException()
1177 
      x.read(self._iprot)
1178 
      self._iprot.readMessageEnd()
1179 
      raise x
1180 
    result = getAllItems_result()
1181 
    result.read(self._iprot)
1182 
    self._iprot.readMessageEnd()
1183 
    if result.success is not None:
1184 
      return result.success
1185 
    if result.cex is not None:
1186 
      raise result.cex
1187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1188 
 
1189 
  def getAllItemsByStatus(self, itemStatus):
1190 
    """
1191 
    Parameters:
1192 
     - itemStatus
1193 
    """
1194 
    self.send_getAllItemsByStatus(itemStatus)
1195 
    return self.recv_getAllItemsByStatus()
1196 
 
1197 
  def send_getAllItemsByStatus(self, itemStatus):
1198 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1199 
    args = getAllItemsByStatus_args()
1200 
    args.itemStatus = itemStatus
1201 
    args.write(self._oprot)
1202 
    self._oprot.writeMessageEnd()
1203 
    self._oprot.trans.flush()
1204 
 
1205 
  def recv_getAllItemsByStatus(self, ):
1206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1207 
    if mtype == TMessageType.EXCEPTION:
1208 
      x = TApplicationException()
1209 
      x.read(self._iprot)
1210 
      self._iprot.readMessageEnd()
1211 
      raise x
1212 
    result = getAllItemsByStatus_result()
1213 
    result.read(self._iprot)
1214 
    self._iprot.readMessageEnd()
1215 
    if result.success is not None:
1216 
      return result.success
1217 
    if result.cex is not None:
1218 
      raise result.cex
1219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1220 
 
1221 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1222 
    """
1223 
    Parameters:
1224 
     - entityId
1225 
     - category
1226 
     - brand
1227 
     - modelName
1228 
     - modelNumber
1229 
    """
1230 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1231 
    return self.recv_markItemAsContentComplete()
1232 
 
1233 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1234 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1235 
    args = markItemAsContentComplete_args()
1236 
    args.entityId = entityId
1237 
    args.category = category
1238 
    args.brand = brand
1239 
    args.modelName = modelName
1240 
    args.modelNumber = modelNumber
1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
1245 
  def recv_markItemAsContentComplete(self, ):
1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
1252 
    result = markItemAsContentComplete_result()
1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
1255 
    if result.success is not None:
1256 
      return result.success
1257 
    if result.cex is not None:
1258 
      raise result.cex
1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1260 
 
1261 
  def getAllItemsInRange(self, offset, limit):
1262 
    """
1263 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1264 
 
1265 
    Parameters:
1266 
     - offset
1267 
     - limit
1268 
    """
1269 
    self.send_getAllItemsInRange(offset, limit)
1270 
    return self.recv_getAllItemsInRange()
1271 
 
1272 
  def send_getAllItemsInRange(self, offset, limit):
1273 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1274 
    args = getAllItemsInRange_args()
1275 
    args.offset = offset
1276 
    args.limit = limit
1277 
    args.write(self._oprot)
1278 
    self._oprot.writeMessageEnd()
1279 
    self._oprot.trans.flush()
1280 
 
1281 
  def recv_getAllItemsInRange(self, ):
1282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1283 
    if mtype == TMessageType.EXCEPTION:
1284 
      x = TApplicationException()
1285 
      x.read(self._iprot)
1286 
      self._iprot.readMessageEnd()
1287 
      raise x
1288 
    result = getAllItemsInRange_result()
1289 
    result.read(self._iprot)
1290 
    self._iprot.readMessageEnd()
1291 
    if result.success is not None:
1292 
      return result.success
1293 
    if result.cex is not None:
1294 
      raise result.cex
1295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1296 
 
1297 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1298 
    """
1299 
    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.
1300 
 
1301 
    Parameters:
1302 
     - itemStatus
1303 
     - offset
1304 
     - limit
1305 
    """
1306 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1307 
    return self.recv_getAllItemsByStatusInRange()
1308 
 
1309 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1310 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1311 
    args = getAllItemsByStatusInRange_args()
1312 
    args.itemStatus = itemStatus
1313 
    args.offset = offset
1314 
    args.limit = limit
1315 
    args.write(self._oprot)
1316 
    self._oprot.writeMessageEnd()
1317 
    self._oprot.trans.flush()
1318 
 
1319 
  def recv_getAllItemsByStatusInRange(self, ):
1320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1321 
    if mtype == TMessageType.EXCEPTION:
1322 
      x = TApplicationException()
1323 
      x.read(self._iprot)
1324 
      self._iprot.readMessageEnd()
1325 
      raise x
1326 
    result = getAllItemsByStatusInRange_result()
1327 
    result.read(self._iprot)
1328 
    self._iprot.readMessageEnd()
1329 
    if result.success is not None:
1330 
      return result.success
1331 
    if result.cex is not None:
1332 
      raise result.cex
1333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1334 
 
1335 
  def getItemCountByStatus(self, useStatus, itemStatus):
1336 
    """
1337 
    Gets a count of all items by status
1338 
 
1339 
    Parameters:
1340 
     - useStatus
1341 
     - itemStatus
1342 
    """
1343 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1344 
    return self.recv_getItemCountByStatus()
1345 
 
1346 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1347 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1348 
    args = getItemCountByStatus_args()
1349 
    args.useStatus = useStatus
1350 
    args.itemStatus = itemStatus
1351 
    args.write(self._oprot)
1352 
    self._oprot.writeMessageEnd()
1353 
    self._oprot.trans.flush()
1354 
 
1355 
  def recv_getItemCountByStatus(self, ):
1356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1357 
    if mtype == TMessageType.EXCEPTION:
1358 
      x = TApplicationException()
1359 
      x.read(self._iprot)
1360 
      self._iprot.readMessageEnd()
1361 
      raise x
1362 
    result = getItemCountByStatus_result()
1363 
    result.read(self._iprot)
1364 
    self._iprot.readMessageEnd()
1365 
    if result.success is not None:
1366 
      return result.success
1367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1368 
 
1369 
  def getBestSellers(self, ):
1370 
    self.send_getBestSellers()
1371 
    return self.recv_getBestSellers()
1372 
 
1373 
  def send_getBestSellers(self, ):
1374 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1375 
    args = getBestSellers_args()
1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getBestSellers(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getBestSellers_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
1390 
    if result.success is not None:
1391 
      return result.success
1392 
    if result.isex is not None:
1393 
      raise result.isex
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1395 
 
1396 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1397 
    """
1398 
    Parameters:
1399 
     - beginIndex
1400 
     - totalItems
1401 
     - brand
1402 
     - category
1403 
    """
1404 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1405 
    return self.recv_getBestSellersCatalogIds()
1406 
 
1407 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1408 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1409 
    args = getBestSellersCatalogIds_args()
1410 
    args.beginIndex = beginIndex
1411 
    args.totalItems = totalItems
1412 
    args.brand = brand
1413 
    args.category = category
1414 
    args.write(self._oprot)
1415 
    self._oprot.writeMessageEnd()
1416 
    self._oprot.trans.flush()
1417 
 
1418 
  def recv_getBestSellersCatalogIds(self, ):
1419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1420 
    if mtype == TMessageType.EXCEPTION:
1421 
      x = TApplicationException()
1422 
      x.read(self._iprot)
1423 
      self._iprot.readMessageEnd()
1424 
      raise x
1425 
    result = getBestSellersCatalogIds_result()
1426 
    result.read(self._iprot)
1427 
    self._iprot.readMessageEnd()
1428 
    if result.success is not None:
1429 
      return result.success
1430 
    if result.cex is not None:
1431 
      raise result.cex
1432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1433 
 
1434 
  def getBestSellersCount(self, ):
1435 
    self.send_getBestSellersCount()
1436 
    return self.recv_getBestSellersCount()
1437 
 
1438 
  def send_getBestSellersCount(self, ):
1439 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1440 
    args = getBestSellersCount_args()
1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
1445 
  def recv_getBestSellersCount(self, ):
1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
1452 
    result = getBestSellersCount_result()
1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
1455 
    if result.success is not None:
1456 
      return result.success
1457 
    if result.cex is not None:
1458 
      raise result.cex
1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1460 
 
1461 
  def getBestDeals(self, ):
1462 
    self.send_getBestDeals()
1463 
    return self.recv_getBestDeals()
1464 
 
1465 
  def send_getBestDeals(self, ):
1466 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1467 
    args = getBestDeals_args()
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getBestDeals(self, ):
1473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1474 
    if mtype == TMessageType.EXCEPTION:
1475 
      x = TApplicationException()
1476 
      x.read(self._iprot)
1477 
      self._iprot.readMessageEnd()
1478 
      raise x
1479 
    result = getBestDeals_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
1482 
    if result.success is not None:
1483 
      return result.success
1484 
    if result.isex is not None:
1485 
      raise result.isex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1487 
 
1488 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1489 
    """
1490 
    Parameters:
1491 
     - beginIndex
1492 
     - totalItems
1493 
     - brand
1494 
     - category
1495 
    """
1496 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1497 
    return self.recv_getBestDealsCatalogIds()
1498 
 
1499 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1500 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1501 
    args = getBestDealsCatalogIds_args()
1502 
    args.beginIndex = beginIndex
1503 
    args.totalItems = totalItems
1504 
    args.brand = brand
1505 
    args.category = category
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getBestDealsCatalogIds(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getBestDealsCatalogIds_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
1520 
    if result.success is not None:
1521 
      return result.success
1522 
    if result.cex is not None:
1523 
      raise result.cex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1525 
 
1526 
  def getBestDealsCount(self, ):
1527 
    self.send_getBestDealsCount()
1528 
    return self.recv_getBestDealsCount()
1529 
 
1530 
  def send_getBestDealsCount(self, ):
1531 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1532 
    args = getBestDealsCount_args()
1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getBestDealsCount(self, ):
1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
1544 
    result = getBestDealsCount_result()
1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
1547 
    if result.success is not None:
1548 
      return result.success
1549 
    if result.cex is not None:
1550 
      raise result.cex
1551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1552 
 
1553 
  def getComingSoon(self, ):
1554 
    self.send_getComingSoon()
1555 
    return self.recv_getComingSoon()
1556 
 
1557 
  def send_getComingSoon(self, ):
1558 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1559 
    args = getComingSoon_args()
1560 
    args.write(self._oprot)
1561 
    self._oprot.writeMessageEnd()
1562 
    self._oprot.trans.flush()
1563 
 
1564 
  def recv_getComingSoon(self, ):
1565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1566 
    if mtype == TMessageType.EXCEPTION:
1567 
      x = TApplicationException()
1568 
      x.read(self._iprot)
1569 
      self._iprot.readMessageEnd()
1570 
      raise x
1571 
    result = getComingSoon_result()
1572 
    result.read(self._iprot)
1573 
    self._iprot.readMessageEnd()
1574 
    if result.success is not None:
1575 
      return result.success
1576 
    if result.isex is not None:
1577 
      raise result.isex
1578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1579 
 
1580 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1581 
    """
1582 
    Parameters:
1583 
     - beginIndex
1584 
     - totalItems
1585 
     - brand
1586 
     - category
1587 
    """
1588 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1589 
    return self.recv_getComingSoonCatalogIds()
1590 
 
1591 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1592 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1593 
    args = getComingSoonCatalogIds_args()
1594 
    args.beginIndex = beginIndex
1595 
    args.totalItems = totalItems
1596 
    args.brand = brand
1597 
    args.category = category
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_getComingSoonCatalogIds(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = getComingSoonCatalogIds_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
1612 
    if result.success is not None:
1613 
      return result.success
1614 
    if result.cex is not None:
1615 
      raise result.cex
1616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1617 
 
1618 
  def getComingSoonCount(self, ):
1619 
    self.send_getComingSoonCount()
1620 
    return self.recv_getComingSoonCount()
1621 
 
1622 
  def send_getComingSoonCount(self, ):
1623 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1624 
    args = getComingSoonCount_args()
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getComingSoonCount(self, ):
1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
1636 
    result = getComingSoonCount_result()
1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
1639 
    if result.success is not None:
1640 
      return result.success
1641 
    if result.cex is not None:
1642 
      raise result.cex
1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1644 
 
1645 
  def getLatestArrivals(self, ):
1646 
    """
1647 
    Returns a list of items sorted in the descending order by start date.
1648 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1649 
    """
1650 
    self.send_getLatestArrivals()
1651 
    return self.recv_getLatestArrivals()
1652 
 
1653 
  def send_getLatestArrivals(self, ):
1654 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1655 
    args = getLatestArrivals_args()
1656 
    args.write(self._oprot)
1657 
    self._oprot.writeMessageEnd()
1658 
    self._oprot.trans.flush()
1659 
 
1660 
  def recv_getLatestArrivals(self, ):
1661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1662 
    if mtype == TMessageType.EXCEPTION:
1663 
      x = TApplicationException()
1664 
      x.read(self._iprot)
1665 
      self._iprot.readMessageEnd()
1666 
      raise x
1667 
    result = getLatestArrivals_result()
1668 
    result.read(self._iprot)
1669 
    self._iprot.readMessageEnd()
1670 
    if result.success is not None:
1671 
      return result.success
1672 
    if result.isex is not None:
1673 
      raise result.isex
1674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1675 
 
1676 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1677 
    """
1678 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1679 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1680 
 
1681 
    Parameters:
1682 
     - beginIndex
1683 
     - totalItems
1684 
     - brand
1685 
     - categories
1686 
    """
1687 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1688 
    return self.recv_getLatestArrivalsCatalogIds()
1689 
 
1690 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1691 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1692 
    args = getLatestArrivalsCatalogIds_args()
1693 
    args.beginIndex = beginIndex
1694 
    args.totalItems = totalItems
1695 
    args.brand = brand
1696 
    args.categories = categories
1697 
    args.write(self._oprot)
1698 
    self._oprot.writeMessageEnd()
1699 
    self._oprot.trans.flush()
1700 
 
1701 
  def recv_getLatestArrivalsCatalogIds(self, ):
1702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1703 
    if mtype == TMessageType.EXCEPTION:
1704 
      x = TApplicationException()
1705 
      x.read(self._iprot)
1706 
      self._iprot.readMessageEnd()
1707 
      raise x
1708 
    result = getLatestArrivalsCatalogIds_result()
1709 
    result.read(self._iprot)
1710 
    self._iprot.readMessageEnd()
1711 
    if result.success is not None:
1712 
      return result.success
1713 
    if result.cex is not None:
1714 
      raise result.cex
1715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1716 
 
1717 
  def getLatestArrivalsCount(self, ):
1718 
    """
1719 
    Get the total number of latest arrivals we are willing to show.
1720 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1721 
    """
1722 
    self.send_getLatestArrivalsCount()
1723 
    return self.recv_getLatestArrivalsCount()
1724 
 
1725 
  def send_getLatestArrivalsCount(self, ):
1726 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1727 
    args = getLatestArrivalsCount_args()
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getLatestArrivalsCount(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getLatestArrivalsCount_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
1742 
    if result.success is not None:
1743 
      return result.success
1744 
    if result.cex is not None:
1745 
      raise result.cex
1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1747 
 
1748 
  def generateNewEntityID(self, ):
1749 
    self.send_generateNewEntityID()
1750 
    return self.recv_generateNewEntityID()
1751 
 
1752 
  def send_generateNewEntityID(self, ):
1753 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1754 
    args = generateNewEntityID_args()
1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_generateNewEntityID(self, ):
1760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1761 
    if mtype == TMessageType.EXCEPTION:
1762 
      x = TApplicationException()
1763 
      x.read(self._iprot)
1764 
      self._iprot.readMessageEnd()
1765 
      raise x
1766 
    result = generateNewEntityID_result()
1767 
    result.read(self._iprot)
1768 
    self._iprot.readMessageEnd()
1769 
    if result.success is not None:
1770 
      return result.success
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1772 
 
1773 
  def addCategory(self, category):
1774 
    """
1775 
    All category related functions
1776 
 
1777 
    Parameters:
1778 
     - category
1779 
    """
1780 
    self.send_addCategory(category)
1781 
    return self.recv_addCategory()
1782 
 
1783 
  def send_addCategory(self, category):
1784 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1785 
    args = addCategory_args()
1786 
    args.category = category
1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1791 
  def recv_addCategory(self, ):
1792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1793 
    if mtype == TMessageType.EXCEPTION:
1794 
      x = TApplicationException()
1795 
      x.read(self._iprot)
1796 
      self._iprot.readMessageEnd()
1797 
      raise x
1798 
    result = addCategory_result()
1799 
    result.read(self._iprot)
1800 
    self._iprot.readMessageEnd()
1801 
    if result.success is not None:
1802 
      return result.success
1803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1804 
 
1805 
  def getCategory(self, id):
1806 
    """
1807 
    Parameters:
1808 
     - id
1809 
    """
1810 
    self.send_getCategory(id)
1811 
    return self.recv_getCategory()
1812 
 
1813 
  def send_getCategory(self, id):
1814 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1815 
    args = getCategory_args()
1816 
    args.id = id
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_getCategory(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = getCategory_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
1831 
    if result.success is not None:
1832 
      return result.success
1833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1834 
 
1835 
  def getAllCategories(self, ):
1836 
    self.send_getAllCategories()
1837 
    return self.recv_getAllCategories()
1838 
 
1839 
  def send_getAllCategories(self, ):
1840 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1841 
    args = getAllCategories_args()
1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
1846 
  def recv_getAllCategories(self, ):
1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
1853 
    result = getAllCategories_result()
1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
1856 
    if result.success is not None:
1857 
      return result.success
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1859 
 
1860 
  def getAllSimilarItems(self, itemId):
1861 
    """
1862 
    Returns the list of similar items.
1863 
 
1864 
    Parameters:
1865 
     - itemId
1866 
    """
1867 
    self.send_getAllSimilarItems(itemId)
1868 
    return self.recv_getAllSimilarItems()
1869 
 
1870 
  def send_getAllSimilarItems(self, itemId):
1871 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1872 
    args = getAllSimilarItems_args()
1873 
    args.itemId = itemId
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_getAllSimilarItems(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = getAllSimilarItems_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
1888 
    if result.success is not None:
1889 
      return result.success
1890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1891 
 
1892 
  def addSimilarItem(self, itemId, catalogItemId):
1893 
    """
1894 
    Adds similar item.
1895 
 
1896 
    Parameters:
1897 
     - itemId
1898 
     - catalogItemId
1899 
    """
1900 
    self.send_addSimilarItem(itemId, catalogItemId)
1901 
    return self.recv_addSimilarItem()
1902 
 
1903 
  def send_addSimilarItem(self, itemId, catalogItemId):
1904 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1905 
    args = addSimilarItem_args()
1906 
    args.itemId = itemId
1907 
    args.catalogItemId = catalogItemId
1908 
    args.write(self._oprot)
1909 
    self._oprot.writeMessageEnd()
1910 
    self._oprot.trans.flush()
1911 
 
1912 
  def recv_addSimilarItem(self, ):
1913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1914 
    if mtype == TMessageType.EXCEPTION:
1915 
      x = TApplicationException()
1916 
      x.read(self._iprot)
1917 
      self._iprot.readMessageEnd()
1918 
      raise x
1919 
    result = addSimilarItem_result()
1920 
    result.read(self._iprot)
1921 
    self._iprot.readMessageEnd()
1922 
    if result.success is not None:
1923 
      return result.success
1924 
    if result.cex is not None:
1925 
      raise result.cex
1926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1927 
 
6512 kshitij.so 1928 
  def addTag(self, displayName, itemId):
1929 
    """
1930 
    Tag Related
1931 
 
1932 
    Parameters:
1933 
     - displayName
1934 
     - itemId
1935 
    """
1936 
    self.send_addTag(displayName, itemId)
1937 
    return self.recv_addTag()
1938 
 
1939 
  def send_addTag(self, displayName, itemId):
1940 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1941 
    args = addTag_args()
1942 
    args.displayName = displayName
1943 
    args.itemId = itemId
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_addTag(self, ):
1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
1955 
    result = addTag_result()
1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
1958 
    if result.success is not None:
1959 
      return result.success
1960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1961 
 
1962 
  def deleteEntityTag(self, displayName, itemId):
1963 
    """
1964 
    Parameters:
1965 
     - displayName
1966 
     - itemId
1967 
    """
1968 
    self.send_deleteEntityTag(displayName, itemId)
1969 
    return self.recv_deleteEntityTag()
1970 
 
1971 
  def send_deleteEntityTag(self, displayName, itemId):
1972 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1973 
    args = deleteEntityTag_args()
1974 
    args.displayName = displayName
1975 
    args.itemId = itemId
1976 
    args.write(self._oprot)
1977 
    self._oprot.writeMessageEnd()
1978 
    self._oprot.trans.flush()
1979 
 
1980 
  def recv_deleteEntityTag(self, ):
1981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1982 
    if mtype == TMessageType.EXCEPTION:
1983 
      x = TApplicationException()
1984 
      x.read(self._iprot)
1985 
      self._iprot.readMessageEnd()
1986 
      raise x
1987 
    result = deleteEntityTag_result()
1988 
    result.read(self._iprot)
1989 
    self._iprot.readMessageEnd()
1990 
    if result.success is not None:
1991 
      return result.success
1992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1993 
 
1994 
  def deleteTag(self, displayName):
1995 
    """
1996 
    Parameters:
1997 
     - displayName
1998 
    """
1999 
    self.send_deleteTag(displayName)
2000 
    return self.recv_deleteTag()
2001 
 
2002 
  def send_deleteTag(self, displayName):
2003 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2004 
    args = deleteTag_args()
2005 
    args.displayName = displayName
2006 
    args.write(self._oprot)
2007 
    self._oprot.writeMessageEnd()
2008 
    self._oprot.trans.flush()
2009 
 
2010 
  def recv_deleteTag(self, ):
2011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2012 
    if mtype == TMessageType.EXCEPTION:
2013 
      x = TApplicationException()
2014 
      x.read(self._iprot)
2015 
      self._iprot.readMessageEnd()
2016 
      raise x
2017 
    result = deleteTag_result()
2018 
    result.read(self._iprot)
2019 
    self._iprot.readMessageEnd()
2020 
    if result.success is not None:
2021 
      return result.success
2022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2023 
 
2024 
  def getAllTags(self, ):
2025 
    self.send_getAllTags()
2026 
    return self.recv_getAllTags()
2027 
 
2028 
  def send_getAllTags(self, ):
2029 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2030 
    args = getAllTags_args()
2031 
    args.write(self._oprot)
2032 
    self._oprot.writeMessageEnd()
2033 
    self._oprot.trans.flush()
2034 
 
2035 
  def recv_getAllTags(self, ):
2036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2037 
    if mtype == TMessageType.EXCEPTION:
2038 
      x = TApplicationException()
2039 
      x.read(self._iprot)
2040 
      self._iprot.readMessageEnd()
2041 
      raise x
2042 
    result = getAllTags_result()
2043 
    result.read(self._iprot)
2044 
    self._iprot.readMessageEnd()
2045 
    if result.success is not None:
2046 
      return result.success
2047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2048 
 
2049 
  def getAllEntitiesByTagName(self, displayName):
2050 
    """
2051 
    Parameters:
2052 
     - displayName
2053 
    """
2054 
    self.send_getAllEntitiesByTagName(displayName)
2055 
    return self.recv_getAllEntitiesByTagName()
2056 
 
2057 
  def send_getAllEntitiesByTagName(self, displayName):
2058 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2059 
    args = getAllEntitiesByTagName_args()
2060 
    args.displayName = displayName
2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
2065 
  def recv_getAllEntitiesByTagName(self, ):
2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
2072 
    result = getAllEntitiesByTagName_result()
2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
2075 
    if result.success is not None:
2076 
      return result.success
2077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2078 
 
6845 amit.gupta 2079 
  def getAllEntityTags(self, ):
2080 
    self.send_getAllEntityTags()
2081 
    return self.recv_getAllEntityTags()
2082 
 
2083 
  def send_getAllEntityTags(self, ):
2084 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2085 
    args = getAllEntityTags_args()
2086 
    args.write(self._oprot)
2087 
    self._oprot.writeMessageEnd()
2088 
    self._oprot.trans.flush()
2089 
 
2090 
  def recv_getAllEntityTags(self, ):
2091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2092 
    if mtype == TMessageType.EXCEPTION:
2093 
      x = TApplicationException()
2094 
      x.read(self._iprot)
2095 
      self._iprot.readMessageEnd()
2096 
      raise x
2097 
    result = getAllEntityTags_result()
2098 
    result.read(self._iprot)
2099 
    self._iprot.readMessageEnd()
2100 
    if result.success is not None:
2101 
      return result.success
2102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2103 
 
6850 kshitij.so 2104 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2105 
    """
2106 
    Parameters:
2107 
     - bannerName
2108 
     - imageName
2109 
     - link
2110 
     - priority
2111 
     - isActive
2112 
     - hasMap
2113 
    """
2114 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2115 
    return self.recv_addBanner()
2116 
 
2117 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2118 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2119 
    args = addBanner_args()
2120 
    args.bannerName = bannerName
2121 
    args.imageName = imageName
2122 
    args.link = link
2123 
    args.priority = priority
2124 
    args.isActive = isActive
2125 
    args.hasMap = hasMap
2126 
    args.write(self._oprot)
2127 
    self._oprot.writeMessageEnd()
2128 
    self._oprot.trans.flush()
2129 
 
2130 
  def recv_addBanner(self, ):
2131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2132 
    if mtype == TMessageType.EXCEPTION:
2133 
      x = TApplicationException()
2134 
      x.read(self._iprot)
2135 
      self._iprot.readMessageEnd()
2136 
      raise x
2137 
    result = addBanner_result()
2138 
    result.read(self._iprot)
2139 
    self._iprot.readMessageEnd()
2140 
    if result.success is not None:
2141 
      return result.success
2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2143 
 
2144 
  def getAllBanners(self, ):
2145 
    self.send_getAllBanners()
2146 
    return self.recv_getAllBanners()
2147 
 
2148 
  def send_getAllBanners(self, ):
2149 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2150 
    args = getAllBanners_args()
2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
2155 
  def recv_getAllBanners(self, ):
2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
2162 
    result = getAllBanners_result()
2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
2165 
    if result.success is not None:
2166 
      return result.success
2167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2168 
 
2169 
  def deleteBanner(self, bannerName):
2170 
    """
2171 
    Parameters:
2172 
     - bannerName
2173 
    """
2174 
    self.send_deleteBanner(bannerName)
2175 
    return self.recv_deleteBanner()
2176 
 
2177 
  def send_deleteBanner(self, bannerName):
2178 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2179 
    args = deleteBanner_args()
2180 
    args.bannerName = bannerName
2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_deleteBanner(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = deleteBanner_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
2195 
    if result.success is not None:
2196 
      return result.success
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2198 
 
2199 
  def getBannerDetails(self, bannerName):
2200 
    """
2201 
    Parameters:
2202 
     - bannerName
2203 
    """
2204 
    self.send_getBannerDetails(bannerName)
2205 
    return self.recv_getBannerDetails()
2206 
 
2207 
  def send_getBannerDetails(self, bannerName):
2208 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2209 
    args = getBannerDetails_args()
2210 
    args.bannerName = bannerName
2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
2215 
  def recv_getBannerDetails(self, ):
2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
2222 
    result = getBannerDetails_result()
2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
2225 
    if result.success is not None:
2226 
      return result.success
2227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2228 
 
2229 
  def getActiveBanners(self, ):
2230 
    self.send_getActiveBanners()
2231 
    return self.recv_getActiveBanners()
2232 
 
2233 
  def send_getActiveBanners(self, ):
2234 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2235 
    args = getActiveBanners_args()
2236 
    args.write(self._oprot)
2237 
    self._oprot.writeMessageEnd()
2238 
    self._oprot.trans.flush()
2239 
 
2240 
  def recv_getActiveBanners(self, ):
2241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2242 
    if mtype == TMessageType.EXCEPTION:
2243 
      x = TApplicationException()
2244 
      x.read(self._iprot)
2245 
      self._iprot.readMessageEnd()
2246 
      raise x
2247 
    result = getActiveBanners_result()
2248 
    result.read(self._iprot)
2249 
    self._iprot.readMessageEnd()
2250 
    if result.success is not None:
2251 
      return result.success
2252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2253 
 
6849 kshitij.so 2254 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2255 
    """
2256 
    Parameters:
2257 
     - bannerName
2258 
     - mapLink
2259 
     - coordinates
2260 
    """
2261 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2262 
    return self.recv_addBannerMap()
2263 
 
2264 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2265 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2266 
    args = addBannerMap_args()
2267 
    args.bannerName = bannerName
2268 
    args.mapLink = mapLink
2269 
    args.coordinates = coordinates
2270 
    args.write(self._oprot)
2271 
    self._oprot.writeMessageEnd()
2272 
    self._oprot.trans.flush()
2273 
 
2274 
  def recv_addBannerMap(self, ):
2275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2276 
    if mtype == TMessageType.EXCEPTION:
2277 
      x = TApplicationException()
2278 
      x.read(self._iprot)
2279 
      self._iprot.readMessageEnd()
2280 
      raise x
2281 
    result = addBannerMap_result()
2282 
    result.read(self._iprot)
2283 
    self._iprot.readMessageEnd()
2284 
    if result.success is not None:
2285 
      return result.success
2286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2287 
 
2288 
  def deleteBannerMap(self, bannerName):
2289 
    """
2290 
    Parameters:
2291 
     - bannerName
2292 
    """
2293 
    self.send_deleteBannerMap(bannerName)
2294 
    return self.recv_deleteBannerMap()
2295 
 
2296 
  def send_deleteBannerMap(self, bannerName):
2297 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2298 
    args = deleteBannerMap_args()
2299 
    args.bannerName = bannerName
2300 
    args.write(self._oprot)
2301 
    self._oprot.writeMessageEnd()
2302 
    self._oprot.trans.flush()
2303 
 
2304 
  def recv_deleteBannerMap(self, ):
2305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2306 
    if mtype == TMessageType.EXCEPTION:
2307 
      x = TApplicationException()
2308 
      x.read(self._iprot)
2309 
      self._iprot.readMessageEnd()
2310 
      raise x
2311 
    result = deleteBannerMap_result()
2312 
    result.read(self._iprot)
2313 
    self._iprot.readMessageEnd()
2314 
    if result.success is not None:
2315 
      return result.success
2316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2317 
 
2318 
  def getBannerMapDetails(self, bannerName):
2319 
    """
2320 
    Parameters:
2321 
     - bannerName
2322 
    """
2323 
    self.send_getBannerMapDetails(bannerName)
2324 
    return self.recv_getBannerMapDetails()
2325 
 
2326 
  def send_getBannerMapDetails(self, bannerName):
2327 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2328 
    args = getBannerMapDetails_args()
2329 
    args.bannerName = bannerName
2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_getBannerMapDetails(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = getBannerMapDetails_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
2344 
    if result.success is not None:
2345 
      return result.success
2346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2347 
 
5944 mandeep.dh 2348 
  def deleteSimilarItem(self, itemId, catalogItemId):
2349 
    """
2350 
    Delete similar item.
2351 
 
2352 
    Parameters:
2353 
     - itemId
2354 
     - catalogItemId
2355 
    """
2356 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2357 
    return self.recv_deleteSimilarItem()
2358 
 
2359 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2360 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2361 
    args = deleteSimilarItem_args()
2362 
    args.itemId = itemId
2363 
    args.catalogItemId = catalogItemId
2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_deleteSimilarItem(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = deleteSimilarItem_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    if result.success is not None:
2379 
      return result.success
2380 
    if result.cex is not None:
2381 
      raise result.cex
2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2383 
 
2384 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2385 
    """
2386 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2387 
    If yes, returns the itemId else returns 0
2388 
 
2389 
    Parameters:
2390 
     - brand
2391 
     - modelNumber
2392 
     - modelName
2393 
     - color
2394 
    """
2395 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2396 
    return self.recv_checkSimilarItem()
2397 
 
2398 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2399 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2400 
    args = checkSimilarItem_args()
2401 
    args.brand = brand
2402 
    args.modelNumber = modelNumber
2403 
    args.modelName = modelName
2404 
    args.color = color
2405 
    args.write(self._oprot)
2406 
    self._oprot.writeMessageEnd()
2407 
    self._oprot.trans.flush()
2408 
 
2409 
  def recv_checkSimilarItem(self, ):
2410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2411 
    if mtype == TMessageType.EXCEPTION:
2412 
      x = TApplicationException()
2413 
      x.read(self._iprot)
2414 
      self._iprot.readMessageEnd()
2415 
      raise x
2416 
    result = checkSimilarItem_result()
2417 
    result.read(self._iprot)
2418 
    self._iprot.readMessageEnd()
2419 
    if result.success is not None:
2420 
      return result.success
2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2422 
 
2423 
  def validateRiskyStatus(self, itemId):
2424 
    """
2425 
    Check wether item is risky and change status if inventory is not available for risky items
2426 
 
2427 
    Parameters:
2428 
     - itemId
2429 
    """
2430 
    self.send_validateRiskyStatus(itemId)
2431 
    self.recv_validateRiskyStatus()
2432 
 
2433 
  def send_validateRiskyStatus(self, itemId):
2434 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2435 
    args = validateRiskyStatus_args()
2436 
    args.itemId = itemId
2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
2441 
  def recv_validateRiskyStatus(self, ):
2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
2448 
    result = validateRiskyStatus_result()
2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
2451 
    return
2452 
 
2453 
  def changeItemRiskyFlag(self, itemId, risky):
2454 
    """
2455 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2456 
 
2457 
    Parameters:
2458 
     - itemId
2459 
     - risky
2460 
    """
2461 
    self.send_changeItemRiskyFlag(itemId, risky)
2462 
    self.recv_changeItemRiskyFlag()
2463 
 
2464 
  def send_changeItemRiskyFlag(self, itemId, risky):
2465 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2466 
    args = changeItemRiskyFlag_args()
2467 
    args.itemId = itemId
2468 
    args.risky = risky
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
2473 
  def recv_changeItemRiskyFlag(self, ):
2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
2480 
    result = changeItemRiskyFlag_result()
2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
2483 
    return
2484 
 
2485 
  def getItemsByRiskyFlag(self, ):
2486 
    """
2487 
    Returns list of items marked as risky.
2488 
    """
2489 
    self.send_getItemsByRiskyFlag()
2490 
    return self.recv_getItemsByRiskyFlag()
2491 
 
2492 
  def send_getItemsByRiskyFlag(self, ):
2493 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2494 
    args = getItemsByRiskyFlag_args()
2495 
    args.write(self._oprot)
2496 
    self._oprot.writeMessageEnd()
2497 
    self._oprot.trans.flush()
2498 
 
2499 
  def recv_getItemsByRiskyFlag(self, ):
2500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2501 
    if mtype == TMessageType.EXCEPTION:
2502 
      x = TApplicationException()
2503 
      x.read(self._iprot)
2504 
      self._iprot.readMessageEnd()
2505 
      raise x
2506 
    result = getItemsByRiskyFlag_result()
2507 
    result.read(self._iprot)
2508 
    self._iprot.readMessageEnd()
2509 
    if result.success is not None:
2510 
      return result.success
2511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2512 
 
2513 
  def getItemsForMasterSheet(self, category, brand):
2514 
    """
2515 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2516 
 
2517 
    Parameters:
2518 
     - category
2519 
     - brand
2520 
    """
2521 
    self.send_getItemsForMasterSheet(category, brand)
2522 
    return self.recv_getItemsForMasterSheet()
2523 
 
2524 
  def send_getItemsForMasterSheet(self, category, brand):
2525 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2526 
    args = getItemsForMasterSheet_args()
2527 
    args.category = category
2528 
    args.brand = brand
2529 
    args.write(self._oprot)
2530 
    self._oprot.writeMessageEnd()
2531 
    self._oprot.trans.flush()
2532 
 
2533 
  def recv_getItemsForMasterSheet(self, ):
2534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2535 
    if mtype == TMessageType.EXCEPTION:
2536 
      x = TApplicationException()
2537 
      x.read(self._iprot)
2538 
      self._iprot.readMessageEnd()
2539 
      raise x
2540 
    result = getItemsForMasterSheet_result()
2541 
    result.read(self._iprot)
2542 
    self._iprot.readMessageEnd()
2543 
    if result.success is not None:
2544 
      return result.success
2545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2546 
 
2547 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2548 
    """
2549 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2550 
 
2551 
    Parameters:
2552 
     - beginIndex
2553 
     - totalItems
2554 
     - itemId
2555 
    """
2556 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2557 
    return self.recv_getSimilarItemsCatalogIds()
2558 
 
2559 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2560 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2561 
    args = getSimilarItemsCatalogIds_args()
2562 
    args.beginIndex = beginIndex
2563 
    args.totalItems = totalItems
2564 
    args.itemId = itemId
2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_getSimilarItemsCatalogIds(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = getSimilarItemsCatalogIds_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
2579 
    if result.success is not None:
2580 
      return result.success
2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2582 
 
2583 
  def addProductNotification(self, itemId, email):
2584 
    """
2585 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2586 
 
2587 
    Parameters:
2588 
     - itemId
2589 
     - email
2590 
    """
2591 
    self.send_addProductNotification(itemId, email)
2592 
    return self.recv_addProductNotification()
2593 
 
2594 
  def send_addProductNotification(self, itemId, email):
2595 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2596 
    args = addProductNotification_args()
2597 
    args.itemId = itemId
2598 
    args.email = email
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_addProductNotification(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = addProductNotification_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    if result.success is not None:
2614 
      return result.success
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2616 
 
2617 
  def sendProductNotifications(self, ):
2618 
    """
2619 
    Send the product notifications to the users for items which has stock.
2620 
    """
2621 
    self.send_sendProductNotifications()
2622 
    return self.recv_sendProductNotifications()
2623 
 
2624 
  def send_sendProductNotifications(self, ):
2625 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2626 
    args = sendProductNotifications_args()
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_sendProductNotifications(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = sendProductNotifications_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
2641 
    if result.success is not None:
2642 
      return result.success
2643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2644 
 
2645 
  def getAllBrandsByCategory(self, categoryId):
2646 
    """
2647 
    Returns list of brand names for a given category Id
2648 
 
2649 
    Parameters:
2650 
     - categoryId
2651 
    """
2652 
    self.send_getAllBrandsByCategory(categoryId)
2653 
    return self.recv_getAllBrandsByCategory()
2654 
 
2655 
  def send_getAllBrandsByCategory(self, categoryId):
2656 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2657 
    args = getAllBrandsByCategory_args()
2658 
    args.categoryId = categoryId
2659 
    args.write(self._oprot)
2660 
    self._oprot.writeMessageEnd()
2661 
    self._oprot.trans.flush()
2662 
 
2663 
  def recv_getAllBrandsByCategory(self, ):
2664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2665 
    if mtype == TMessageType.EXCEPTION:
2666 
      x = TApplicationException()
2667 
      x.read(self._iprot)
2668 
      self._iprot.readMessageEnd()
2669 
      raise x
2670 
    result = getAllBrandsByCategory_result()
2671 
    result.read(self._iprot)
2672 
    self._iprot.readMessageEnd()
2673 
    if result.success is not None:
2674 
      return result.success
2675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2676 
 
2677 
  def getAllBrands(self, ):
2678 
    """
2679 
    Returns list of brand names
2680 
    """
2681 
    self.send_getAllBrands()
2682 
    return self.recv_getAllBrands()
2683 
 
2684 
  def send_getAllBrands(self, ):
2685 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2686 
    args = getAllBrands_args()
2687 
    args.write(self._oprot)
2688 
    self._oprot.writeMessageEnd()
2689 
    self._oprot.trans.flush()
2690 
 
2691 
  def recv_getAllBrands(self, ):
2692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2693 
    if mtype == TMessageType.EXCEPTION:
2694 
      x = TApplicationException()
2695 
      x.read(self._iprot)
2696 
      self._iprot.readMessageEnd()
2697 
      raise x
2698 
    result = getAllBrands_result()
2699 
    result.read(self._iprot)
2700 
    self._iprot.readMessageEnd()
2701 
    if result.success is not None:
2702 
      return result.success
2703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2704 
 
2705 
  def getAllSources(self, ):
2706 
    """
2707 
    Return list of all sources
2708 
    """
2709 
    self.send_getAllSources()
2710 
    return self.recv_getAllSources()
2711 
 
2712 
  def send_getAllSources(self, ):
2713 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2714 
    args = getAllSources_args()
2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
2719 
  def recv_getAllSources(self, ):
2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
2726 
    result = getAllSources_result()
2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
2729 
    if result.success is not None:
2730 
      return result.success
2731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2732 
 
2733 
  def getItemPricingBySource(self, itemId, sourceId):
2734 
    """
2735 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2736 
 
2737 
    Parameters:
2738 
     - itemId
2739 
     - sourceId
2740 
    """
2741 
    self.send_getItemPricingBySource(itemId, sourceId)
2742 
    return self.recv_getItemPricingBySource()
2743 
 
2744 
  def send_getItemPricingBySource(self, itemId, sourceId):
2745 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2746 
    args = getItemPricingBySource_args()
2747 
    args.itemId = itemId
2748 
    args.sourceId = sourceId
2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_getItemPricingBySource(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = getItemPricingBySource_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.success is not None:
2764 
      return result.success
2765 
    if result.cex is not None:
2766 
      raise result.cex
2767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2768 
 
2769 
  def addSourceItemPricing(self, sourceItemPricing):
2770 
    """
2771 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2772 
    If item is not found or source is not found, it will throw exception.
2773 
 
2774 
    Parameters:
2775 
     - sourceItemPricing
2776 
    """
2777 
    self.send_addSourceItemPricing(sourceItemPricing)
2778 
    self.recv_addSourceItemPricing()
2779 
 
2780 
  def send_addSourceItemPricing(self, sourceItemPricing):
2781 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2782 
    args = addSourceItemPricing_args()
2783 
    args.sourceItemPricing = sourceItemPricing
2784 
    args.write(self._oprot)
2785 
    self._oprot.writeMessageEnd()
2786 
    self._oprot.trans.flush()
2787 
 
2788 
  def recv_addSourceItemPricing(self, ):
2789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2790 
    if mtype == TMessageType.EXCEPTION:
2791 
      x = TApplicationException()
2792 
      x.read(self._iprot)
2793 
      self._iprot.readMessageEnd()
2794 
      raise x
2795 
    result = addSourceItemPricing_result()
2796 
    result.read(self._iprot)
2797 
    self._iprot.readMessageEnd()
2798 
    if result.cex is not None:
2799 
      raise result.cex
2800 
    return
2801 
 
2802 
  def getAllSourcePricing(self, itemId):
2803 
    """
2804 
    Returns the list of source pricing information of an item.
2805 
    Raises an exception if item not found corresponding to itemId
2806 
 
2807 
    Parameters:
2808 
     - itemId
2809 
    """
2810 
    self.send_getAllSourcePricing(itemId)
2811 
    return self.recv_getAllSourcePricing()
2812 
 
2813 
  def send_getAllSourcePricing(self, itemId):
2814 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2815 
    args = getAllSourcePricing_args()
2816 
    args.itemId = itemId
2817 
    args.write(self._oprot)
2818 
    self._oprot.writeMessageEnd()
2819 
    self._oprot.trans.flush()
2820 
 
2821 
  def recv_getAllSourcePricing(self, ):
2822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2823 
    if mtype == TMessageType.EXCEPTION:
2824 
      x = TApplicationException()
2825 
      x.read(self._iprot)
2826 
      self._iprot.readMessageEnd()
2827 
      raise x
2828 
    result = getAllSourcePricing_result()
2829 
    result.read(self._iprot)
2830 
    self._iprot.readMessageEnd()
2831 
    if result.success is not None:
2832 
      return result.success
2833 
    if result.cex is not None:
2834 
      raise result.cex
2835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2836 
 
2837 
  def getItemForSource(self, item_id, sourceId):
2838 
    """
2839 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2840 
 
2841 
    Parameters:
2842 
     - item_id
2843 
     - sourceId
2844 
    """
2845 
    self.send_getItemForSource(item_id, sourceId)
2846 
    return self.recv_getItemForSource()
2847 
 
2848 
  def send_getItemForSource(self, item_id, sourceId):
2849 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2850 
    args = getItemForSource_args()
2851 
    args.item_id = item_id
2852 
    args.sourceId = sourceId
2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
2857 
  def recv_getItemForSource(self, ):
2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
2864 
    result = getItemForSource_result()
2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
2867 
    if result.success is not None:
2868 
      return result.success
2869 
    if result.cex is not None:
2870 
      raise result.cex
2871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2872 
 
2873 
  def searchItemsInRange(self, searchTerms, offset, limit):
2874 
    """
2875 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2876 
 
2877 
    Parameters:
2878 
     - searchTerms
2879 
     - offset
2880 
     - limit
2881 
    """
2882 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2883 
    return self.recv_searchItemsInRange()
2884 
 
2885 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2886 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2887 
    args = searchItemsInRange_args()
2888 
    args.searchTerms = searchTerms
2889 
    args.offset = offset
2890 
    args.limit = limit
2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2895 
  def recv_searchItemsInRange(self, ):
2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2902 
    result = searchItemsInRange_result()
2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.success is not None:
2906 
      return result.success
2907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2908 
 
2909 
  def getSearchResultCount(self, searchTerms):
2910 
    """
2911 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2912 
 
2913 
    Parameters:
2914 
     - searchTerms
2915 
    """
2916 
    self.send_getSearchResultCount(searchTerms)
2917 
    return self.recv_getSearchResultCount()
2918 
 
2919 
  def send_getSearchResultCount(self, searchTerms):
2920 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2921 
    args = getSearchResultCount_args()
2922 
    args.searchTerms = searchTerms
2923 
    args.write(self._oprot)
2924 
    self._oprot.writeMessageEnd()
2925 
    self._oprot.trans.flush()
2926 
 
2927 
  def recv_getSearchResultCount(self, ):
2928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2929 
    if mtype == TMessageType.EXCEPTION:
2930 
      x = TApplicationException()
2931 
      x.read(self._iprot)
2932 
      self._iprot.readMessageEnd()
2933 
      raise x
2934 
    result = getSearchResultCount_result()
2935 
    result.read(self._iprot)
2936 
    self._iprot.readMessageEnd()
2937 
    if result.success is not None:
2938 
      return result.success
2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2940 
 
2941 
  def getProductNotifications(self, startDateTime):
2942 
    """
2943 
    Returns a list of product notifications added after a supplied datetime
2944 
 
2945 
    Parameters:
2946 
     - startDateTime
2947 
    """
2948 
    self.send_getProductNotifications(startDateTime)
2949 
    return self.recv_getProductNotifications()
2950 
 
2951 
  def send_getProductNotifications(self, startDateTime):
2952 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2953 
    args = getProductNotifications_args()
2954 
    args.startDateTime = startDateTime
2955 
    args.write(self._oprot)
2956 
    self._oprot.writeMessageEnd()
2957 
    self._oprot.trans.flush()
2958 
 
2959 
  def recv_getProductNotifications(self, ):
2960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2961 
    if mtype == TMessageType.EXCEPTION:
2962 
      x = TApplicationException()
2963 
      x.read(self._iprot)
2964 
      self._iprot.readMessageEnd()
2965 
      raise x
2966 
    result = getProductNotifications_result()
2967 
    result.read(self._iprot)
2968 
    self._iprot.readMessageEnd()
2969 
    if result.success is not None:
2970 
      return result.success
2971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2972 
 
7897 amar.kumar 2973 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2974 
    """
2975 
    Returns a list of count of requests for product notification against each item
2976 
 
2977 
    Parameters:
2978 
     - startDateTime
7897 amar.kumar 2979 
     - categoryId
5944 mandeep.dh 2980 
    """
7897 amar.kumar 2981 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 2982 
    return self.recv_getProductNotificationRequestCount()
2983 
 
7897 amar.kumar 2984 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2985 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2986 
    args = getProductNotificationRequestCount_args()
2987 
    args.startDateTime = startDateTime
7897 amar.kumar 2988 
    args.categoryId = categoryId
5944 mandeep.dh 2989 
    args.write(self._oprot)
2990 
    self._oprot.writeMessageEnd()
2991 
    self._oprot.trans.flush()
2992 
 
2993 
  def recv_getProductNotificationRequestCount(self, ):
2994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2995 
    if mtype == TMessageType.EXCEPTION:
2996 
      x = TApplicationException()
2997 
      x.read(self._iprot)
2998 
      self._iprot.readMessageEnd()
2999 
      raise x
3000 
    result = getProductNotificationRequestCount_result()
3001 
    result.read(self._iprot)
3002 
    self._iprot.readMessageEnd()
3003 
    if result.success is not None:
3004 
      return result.success
3005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3006 
 
3007 
  def addAuthorizationLog(self, itemId, username, reason):
3008 
    """
3009 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3010 
 
3011 
    Parameters:
3012 
     - itemId
3013 
     - username
3014 
     - reason
3015 
    """
3016 
    self.send_addAuthorizationLog(itemId, username, reason)
3017 
    return self.recv_addAuthorizationLog()
3018 
 
3019 
  def send_addAuthorizationLog(self, itemId, username, reason):
3020 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3021 
    args = addAuthorizationLog_args()
3022 
    args.itemId = itemId
3023 
    args.username = username
3024 
    args.reason = reason
3025 
    args.write(self._oprot)
3026 
    self._oprot.writeMessageEnd()
3027 
    self._oprot.trans.flush()
3028 
 
3029 
  def recv_addAuthorizationLog(self, ):
3030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3031 
    if mtype == TMessageType.EXCEPTION:
3032 
      x = TApplicationException()
3033 
      x.read(self._iprot)
3034 
      self._iprot.readMessageEnd()
3035 
      raise x
3036 
    result = addAuthorizationLog_result()
3037 
    result.read(self._iprot)
3038 
    self._iprot.readMessageEnd()
3039 
    if result.success is not None:
3040 
      return result.success
3041 
    if result.cex is not None:
3042 
      raise result.cex
3043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3044 
 
3045 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3046 
    """
3047 
    Parameters:
3048 
     - catalog_item_id
3049 
     - voucherType
3050 
     - voucherAmount
3051 
    """
3052 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3053 
    return self.recv_addupdateVoucherForItem()
3054 
 
3055 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3056 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3057 
    args = addupdateVoucherForItem_args()
3058 
    args.catalog_item_id = catalog_item_id
3059 
    args.voucherType = voucherType
3060 
    args.voucherAmount = voucherAmount
3061 
    args.write(self._oprot)
3062 
    self._oprot.writeMessageEnd()
3063 
    self._oprot.trans.flush()
3064 
 
3065 
  def recv_addupdateVoucherForItem(self, ):
3066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3067 
    if mtype == TMessageType.EXCEPTION:
3068 
      x = TApplicationException()
3069 
      x.read(self._iprot)
3070 
      self._iprot.readMessageEnd()
3071 
      raise x
3072 
    result = addupdateVoucherForItem_result()
3073 
    result.read(self._iprot)
3074 
    self._iprot.readMessageEnd()
3075 
    if result.success is not None:
3076 
      return result.success
3077 
    if result.cex is not None:
3078 
      raise result.cex
3079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3080 
 
3081 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3082 
    """
3083 
    Parameters:
3084 
     - catalog_item_id
3085 
     - voucherType
3086 
    """
3087 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3088 
    return self.recv_deleteVoucherForItem()
3089 
 
3090 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3091 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3092 
    args = deleteVoucherForItem_args()
3093 
    args.catalog_item_id = catalog_item_id
3094 
    args.voucherType = voucherType
3095 
    args.write(self._oprot)
3096 
    self._oprot.writeMessageEnd()
3097 
    self._oprot.trans.flush()
3098 
 
3099 
  def recv_deleteVoucherForItem(self, ):
3100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3101 
    if mtype == TMessageType.EXCEPTION:
3102 
      x = TApplicationException()
3103 
      x.read(self._iprot)
3104 
      self._iprot.readMessageEnd()
3105 
      raise x
3106 
    result = deleteVoucherForItem_result()
3107 
    result.read(self._iprot)
3108 
    self._iprot.readMessageEnd()
3109 
    if result.success is not None:
3110 
      return result.success
3111 
    if result.cex is not None:
3112 
      raise result.cex
3113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3114 
 
3115 
  def getVoucherAmount(self, itemId, voucherType):
3116 
    """
3117 
    Parameters:
3118 
     - itemId
3119 
     - voucherType
3120 
    """
3121 
    self.send_getVoucherAmount(itemId, voucherType)
3122 
    return self.recv_getVoucherAmount()
3123 
 
3124 
  def send_getVoucherAmount(self, itemId, voucherType):
3125 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3126 
    args = getVoucherAmount_args()
3127 
    args.itemId = itemId
3128 
    args.voucherType = voucherType
3129 
    args.write(self._oprot)
3130 
    self._oprot.writeMessageEnd()
3131 
    self._oprot.trans.flush()
3132 
 
3133 
  def recv_getVoucherAmount(self, ):
3134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3135 
    if mtype == TMessageType.EXCEPTION:
3136 
      x = TApplicationException()
3137 
      x.read(self._iprot)
3138 
      self._iprot.readMessageEnd()
3139 
      raise x
3140 
    result = getVoucherAmount_result()
3141 
    result.read(self._iprot)
3142 
    self._iprot.readMessageEnd()
3143 
    if result.success is not None:
3144 
      return result.success
3145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3146 
 
3147 
  def getAllItemVouchers(self, itemId):
3148 
    """
3149 
    Parameters:
3150 
     - itemId
3151 
    """
3152 
    self.send_getAllItemVouchers(itemId)
3153 
    return self.recv_getAllItemVouchers()
3154 
 
3155 
  def send_getAllItemVouchers(self, itemId):
3156 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3157 
    args = getAllItemVouchers_args()
3158 
    args.itemId = itemId
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_getAllItemVouchers(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = getAllItemVouchers_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3173 
    if result.success is not None:
3174 
      return result.success
3175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3176 
 
3177 
  def isValidCatalogItemId(self, catalog_item_id):
3178 
    """
3179 
    Parameters:
3180 
     - catalog_item_id
3181 
    """
3182 
    self.send_isValidCatalogItemId(catalog_item_id)
3183 
    return self.recv_isValidCatalogItemId()
3184 
 
3185 
  def send_isValidCatalogItemId(self, catalog_item_id):
3186 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3187 
    args = isValidCatalogItemId_args()
3188 
    args.catalog_item_id = catalog_item_id
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_isValidCatalogItemId(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = isValidCatalogItemId_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
3203 
    if result.success is not None:
3204 
      return result.success
3205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3206 
 
7330 amit.gupta 3207 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3208 
    """
3209 
    Parameters:
3210 
     - itemId
7330 amit.gupta 3211 
     - stateId
6039 amit.gupta 3212 
     - price
3213 
    """
7330 amit.gupta 3214 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3215 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3216 
 
7330 amit.gupta 3217 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3218 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3219 
    args = getVatPercentageForItem_args()
3220 
    args.itemId = itemId
7330 amit.gupta 3221 
    args.stateId = stateId
6039 amit.gupta 3222 
    args.price = price
3223 
    args.write(self._oprot)
3224 
    self._oprot.writeMessageEnd()
3225 
    self._oprot.trans.flush()
3226 
 
3227 
  def recv_getVatPercentageForItem(self, ):
3228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3229 
    if mtype == TMessageType.EXCEPTION:
3230 
      x = TApplicationException()
3231 
      x.read(self._iprot)
3232 
      self._iprot.readMessageEnd()
3233 
      raise x
3234 
    result = getVatPercentageForItem_result()
3235 
    result.read(self._iprot)
3236 
    self._iprot.readMessageEnd()
3237 
    if result.success is not None:
3238 
      return result.success
7340 amit.gupta 3239 
    if result.cex is not None:
3240 
      raise result.cex
6039 amit.gupta 3241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3242 
 
3243 
  def getVatAmountForItem(self, itemId, price):
3244 
    """
3245 
    Parameters:
3246 
     - itemId
3247 
     - price
3248 
    """
3249 
    self.send_getVatAmountForItem(itemId, price)
3250 
    return self.recv_getVatAmountForItem()
3251 
 
3252 
  def send_getVatAmountForItem(self, itemId, price):
3253 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3254 
    args = getVatAmountForItem_args()
3255 
    args.itemId = itemId
3256 
    args.price = price
3257 
    args.write(self._oprot)
3258 
    self._oprot.writeMessageEnd()
3259 
    self._oprot.trans.flush()
3260 
 
3261 
  def recv_getVatAmountForItem(self, ):
3262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3263 
    if mtype == TMessageType.EXCEPTION:
3264 
      x = TApplicationException()
3265 
      x.read(self._iprot)
3266 
      self._iprot.readMessageEnd()
3267 
      raise x
3268 
    result = getVatAmountForItem_result()
3269 
    result.read(self._iprot)
3270 
    self._iprot.readMessageEnd()
3271 
    if result.success is not None:
3272 
      return result.success
3273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3274 
 
6531 vikram.rag 3275 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3276 
    """
3277 
    Parameters:
3278 
     - offset
3279 
     - limit
3280 
    """
3281 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3282 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3283 
 
6531 vikram.rag 3284 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3285 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3286 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3287 
    args.offset = offset
3288 
    args.limit = limit
3289 
    args.write(self._oprot)
3290 
    self._oprot.writeMessageEnd()
3291 
    self._oprot.trans.flush()
3292 
 
3293 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3295 
    if mtype == TMessageType.EXCEPTION:
3296 
      x = TApplicationException()
3297 
      x.read(self._iprot)
3298 
      self._iprot.readMessageEnd()
3299 
      raise x
3300 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3301 
    result.read(self._iprot)
3302 
    self._iprot.readMessageEnd()
3303 
    if result.success is not None:
3304 
      return result.success
3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3306 
 
6821 amar.kumar 3307 
  def getAllAliveItems(self, ):
3308 
    self.send_getAllAliveItems()
3309 
    return self.recv_getAllAliveItems()
3310 
 
3311 
  def send_getAllAliveItems(self, ):
3312 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3313 
    args = getAllAliveItems_args()
3314 
    args.write(self._oprot)
3315 
    self._oprot.writeMessageEnd()
3316 
    self._oprot.trans.flush()
3317 
 
3318 
  def recv_getAllAliveItems(self, ):
3319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3320 
    if mtype == TMessageType.EXCEPTION:
3321 
      x = TApplicationException()
3322 
      x.read(self._iprot)
3323 
      self._iprot.readMessageEnd()
3324 
      raise x
3325 
    result = getAllAliveItems_result()
3326 
    result.read(self._iprot)
3327 
    self._iprot.readMessageEnd()
3328 
    if result.success is not None:
3329 
      return result.success
3330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3331 
 
6921 anupam.sin 3332 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3333 
    """
3334 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3335 
 
6805 anupam.sin 3336 
    Parameters:
3337 
     - itemId
6921 anupam.sin 3338 
     - price
6805 anupam.sin 3339 
     - insurerId
3340 
     - quantity
3341 
    """
6921 anupam.sin 3342 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3343 
    return self.recv_getInsuranceAmount()
3344 
 
6921 anupam.sin 3345 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3346 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3347 
    args = getInsuranceAmount_args()
3348 
    args.itemId = itemId
6921 anupam.sin 3349 
    args.price = price
6805 anupam.sin 3350 
    args.insurerId = insurerId
3351 
    args.quantity = quantity
3352 
    args.write(self._oprot)
3353 
    self._oprot.writeMessageEnd()
3354 
    self._oprot.trans.flush()
3355 
 
3356 
  def recv_getInsuranceAmount(self, ):
3357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3358 
    if mtype == TMessageType.EXCEPTION:
3359 
      x = TApplicationException()
3360 
      x.read(self._iprot)
3361 
      self._iprot.readMessageEnd()
3362 
      raise x
3363 
    result = getInsuranceAmount_result()
3364 
    result.read(self._iprot)
3365 
    self._iprot.readMessageEnd()
3366 
    if result.success is not None:
3367 
      return result.success
3368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3369 
 
3370 
  def getInsurer(self, insurerId):
3371 
    """
3372 
    Parameters:
3373 
     - insurerId
3374 
    """
3375 
    self.send_getInsurer(insurerId)
3376 
    return self.recv_getInsurer()
3377 
 
3378 
  def send_getInsurer(self, insurerId):
3379 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3380 
    args = getInsurer_args()
3381 
    args.insurerId = insurerId
3382 
    args.write(self._oprot)
3383 
    self._oprot.writeMessageEnd()
3384 
    self._oprot.trans.flush()
3385 
 
3386 
  def recv_getInsurer(self, ):
3387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3388 
    if mtype == TMessageType.EXCEPTION:
3389 
      x = TApplicationException()
3390 
      x.read(self._iprot)
3391 
      self._iprot.readMessageEnd()
3392 
      raise x
3393 
    result = getInsurer_result()
3394 
    result.read(self._iprot)
3395 
    self._iprot.readMessageEnd()
3396 
    if result.success is not None:
3397 
      return result.success
3398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3399 
 
6838 vikram.rag 3400 
  def getAllInsurers(self, ):
3401 
    self.send_getAllInsurers()
3402 
    return self.recv_getAllInsurers()
6805 anupam.sin 3403 
 
6838 vikram.rag 3404 
  def send_getAllInsurers(self, ):
3405 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3406 
    args = getAllInsurers_args()
3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_getAllInsurers(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = getAllInsurers_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3421 
    if result.success is not None:
3422 
      return result.success
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3424 
 
6962 rajveer 3425 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3426 
    """
3427 
    Parameters:
3428 
     - insurerId
3429 
     - amount
3430 
    """
3431 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3432 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3433 
 
6962 rajveer 3434 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3435 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3436 
    args = updateInsuranceDeclaredAmount_args()
3437 
    args.insurerId = insurerId
3438 
    args.amount = amount
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_updateInsuranceDeclaredAmount(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = updateInsuranceDeclaredAmount_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    return
3454 
 
7190 amar.kumar 3455 
  def getFreebieForItem(self, itemId):
3456 
    """
3457 
    Parameters:
3458 
     - itemId
3459 
    """
3460 
    self.send_getFreebieForItem(itemId)
3461 
    return self.recv_getFreebieForItem()
6962 rajveer 3462 
 
7190 amar.kumar 3463 
  def send_getFreebieForItem(self, itemId):
3464 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3465 
    args = getFreebieForItem_args()
3466 
    args.itemId = itemId
3467 
    args.write(self._oprot)
3468 
    self._oprot.writeMessageEnd()
3469 
    self._oprot.trans.flush()
3470 
 
3471 
  def recv_getFreebieForItem(self, ):
3472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3473 
    if mtype == TMessageType.EXCEPTION:
3474 
      x = TApplicationException()
3475 
      x.read(self._iprot)
3476 
      self._iprot.readMessageEnd()
3477 
      raise x
3478 
    result = getFreebieForItem_result()
3479 
    result.read(self._iprot)
3480 
    self._iprot.readMessageEnd()
3481 
    if result.success is not None:
3482 
      return result.success
3483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3484 
 
3485 
  def addOrUpdateFreebieForItem(self, freebieItem):
3486 
    """
3487 
    Parameters:
3488 
     - freebieItem
3489 
    """
3490 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3491 
    self.recv_addOrUpdateFreebieForItem()
3492 
 
3493 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3494 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3495 
    args = addOrUpdateFreebieForItem_args()
3496 
    args.freebieItem = freebieItem
3497 
    args.write(self._oprot)
3498 
    self._oprot.writeMessageEnd()
3499 
    self._oprot.trans.flush()
3500 
 
3501 
  def recv_addOrUpdateFreebieForItem(self, ):
3502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3503 
    if mtype == TMessageType.EXCEPTION:
3504 
      x = TApplicationException()
3505 
      x.read(self._iprot)
3506 
      self._iprot.readMessageEnd()
3507 
      raise x
3508 
    result = addOrUpdateFreebieForItem_result()
3509 
    result.read(self._iprot)
3510 
    self._iprot.readMessageEnd()
3511 
    return
3512 
 
7272 amit.gupta 3513 
  def addOrUpdateBrandInfo(self, brandInfo):
3514 
    """
3515 
    Parameters:
3516 
     - brandInfo
3517 
    """
3518 
    self.send_addOrUpdateBrandInfo(brandInfo)
3519 
    self.recv_addOrUpdateBrandInfo()
3520 
 
3521 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3522 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3523 
    args = addOrUpdateBrandInfo_args()
3524 
    args.brandInfo = brandInfo
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_addOrUpdateBrandInfo(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = addOrUpdateBrandInfo_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
3539 
    return
3540 
 
3541 
  def getBrandInfo(self, ):
3542 
    self.send_getBrandInfo()
3543 
    return self.recv_getBrandInfo()
3544 
 
3545 
  def send_getBrandInfo(self, ):
3546 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3547 
    args = getBrandInfo_args()
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_getBrandInfo(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = getBrandInfo_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3562 
    if result.success is not None:
3563 
      return result.success
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3565 
 
7256 rajveer 3566 
  def getStorePricing(self, itemId):
3567 
    """
3568 
    Parameters:
3569 
     - itemId
3570 
    """
3571 
    self.send_getStorePricing(itemId)
3572 
    return self.recv_getStorePricing()
7190 amar.kumar 3573 
 
7256 rajveer 3574 
  def send_getStorePricing(self, itemId):
3575 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3576 
    args = getStorePricing_args()
3577 
    args.itemId = itemId
3578 
    args.write(self._oprot)
3579 
    self._oprot.writeMessageEnd()
3580 
    self._oprot.trans.flush()
3581 
 
3582 
  def recv_getStorePricing(self, ):
3583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3584 
    if mtype == TMessageType.EXCEPTION:
3585 
      x = TApplicationException()
3586 
      x.read(self._iprot)
3587 
      self._iprot.readMessageEnd()
3588 
      raise x
3589 
    result = getStorePricing_result()
3590 
    result.read(self._iprot)
3591 
    self._iprot.readMessageEnd()
3592 
    if result.success is not None:
3593 
      return result.success
3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3595 
 
7306 rajveer 3596 
  def getStorePricings(self, itemIds):
3597 
    """
3598 
    Parameters:
3599 
     - itemIds
3600 
    """
3601 
    self.send_getStorePricings(itemIds)
3602 
    return self.recv_getStorePricings()
3603 
 
3604 
  def send_getStorePricings(self, itemIds):
3605 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3606 
    args = getStorePricings_args()
3607 
    args.itemIds = itemIds
3608 
    args.write(self._oprot)
3609 
    self._oprot.writeMessageEnd()
3610 
    self._oprot.trans.flush()
3611 
 
3612 
  def recv_getStorePricings(self, ):
3613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3614 
    if mtype == TMessageType.EXCEPTION:
3615 
      x = TApplicationException()
3616 
      x.read(self._iprot)
3617 
      self._iprot.readMessageEnd()
3618 
      raise x
3619 
    result = getStorePricings_result()
3620 
    result.read(self._iprot)
3621 
    self._iprot.readMessageEnd()
3622 
    if result.success is not None:
3623 
      return result.success
3624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3625 
 
7382 rajveer 3626 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3627 
    """
3628 
    Parameters:
3629 
     - sp
7382 rajveer 3630 
     - allColors
7265 rajveer 3631 
    """
7382 rajveer 3632 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3633 
    self.recv_updateStorePricing()
7256 rajveer 3634 
 
7382 rajveer 3635 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3636 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3637 
    args = updateStorePricing_args()
3638 
    args.sp = sp
7382 rajveer 3639 
    args.allColors = allColors
7265 rajveer 3640 
    args.write(self._oprot)
3641 
    self._oprot.writeMessageEnd()
3642 
    self._oprot.trans.flush()
3643 
 
3644 
  def recv_updateStorePricing(self, ):
3645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3646 
    if mtype == TMessageType.EXCEPTION:
3647 
      x = TApplicationException()
3648 
      x.read(self._iprot)
3649 
      self._iprot.readMessageEnd()
3650 
      raise x
3651 
    result = updateStorePricing_result()
3652 
    result.read(self._iprot)
3653 
    self._iprot.readMessageEnd()
3654 
    return
3655 
 
7281 kshitij.so 3656 
  def getAllAmazonListedItems(self, ):
3657 
    self.send_getAllAmazonListedItems()
3658 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3659 
 
7281 kshitij.so 3660 
  def send_getAllAmazonListedItems(self, ):
3661 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3662 
    args = getAllAmazonListedItems_args()
3663 
    args.write(self._oprot)
3664 
    self._oprot.writeMessageEnd()
3665 
    self._oprot.trans.flush()
3666 
 
3667 
  def recv_getAllAmazonListedItems(self, ):
3668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3669 
    if mtype == TMessageType.EXCEPTION:
3670 
      x = TApplicationException()
3671 
      x.read(self._iprot)
3672 
      self._iprot.readMessageEnd()
3673 
      raise x
3674 
    result = getAllAmazonListedItems_result()
3675 
    result.read(self._iprot)
3676 
    self._iprot.readMessageEnd()
3677 
    if result.success is not None:
3678 
      return result.success
3679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3680 
 
3681 
  def getAmazonItemDetails(self, itemId):
3682 
    """
3683 
    Parameters:
3684 
     - itemId
3685 
    """
3686 
    self.send_getAmazonItemDetails(itemId)
3687 
    return self.recv_getAmazonItemDetails()
3688 
 
3689 
  def send_getAmazonItemDetails(self, itemId):
3690 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3691 
    args = getAmazonItemDetails_args()
3692 
    args.itemId = itemId
3693 
    args.write(self._oprot)
3694 
    self._oprot.writeMessageEnd()
3695 
    self._oprot.trans.flush()
3696 
 
3697 
  def recv_getAmazonItemDetails(self, ):
3698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3699 
    if mtype == TMessageType.EXCEPTION:
3700 
      x = TApplicationException()
3701 
      x.read(self._iprot)
3702 
      self._iprot.readMessageEnd()
3703 
      raise x
3704 
    result = getAmazonItemDetails_result()
3705 
    result.read(self._iprot)
3706 
    self._iprot.readMessageEnd()
3707 
    if result.success is not None:
3708 
      return result.success
3709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3710 
 
8168 kshitij.so 3711 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 3712 
    """
3713 
    Parameters:
8168 kshitij.so 3714 
     - amazonlisted
7281 kshitij.so 3715 
    """
8168 kshitij.so 3716 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 3717 
    self.recv_updateAmazonItemDetails()
3718 
 
8168 kshitij.so 3719 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 3720 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3721 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 3722 
    args.amazonlisted = amazonlisted
7281 kshitij.so 3723 
    args.write(self._oprot)
3724 
    self._oprot.writeMessageEnd()
3725 
    self._oprot.trans.flush()
3726 
 
3727 
  def recv_updateAmazonItemDetails(self, ):
3728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3729 
    if mtype == TMessageType.EXCEPTION:
3730 
      x = TApplicationException()
3731 
      x.read(self._iprot)
3732 
      self._iprot.readMessageEnd()
3733 
      raise x
3734 
    result = updateAmazonItemDetails_result()
3735 
    result.read(self._iprot)
3736 
    self._iprot.readMessageEnd()
3737 
    return
3738 
 
3739 
  def addAmazonItem(self, amazonlisted):
3740 
    """
3741 
    Parameters:
3742 
     - amazonlisted
3743 
    """
3744 
    self.send_addAmazonItem(amazonlisted)
3745 
    self.recv_addAmazonItem()
3746 
 
3747 
  def send_addAmazonItem(self, amazonlisted):
3748 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3749 
    args = addAmazonItem_args()
3750 
    args.amazonlisted = amazonlisted
3751 
    args.write(self._oprot)
3752 
    self._oprot.writeMessageEnd()
3753 
    self._oprot.trans.flush()
3754 
 
3755 
  def recv_addAmazonItem(self, ):
3756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3757 
    if mtype == TMessageType.EXCEPTION:
3758 
      x = TApplicationException()
3759 
      x.read(self._iprot)
3760 
      self._iprot.readMessageEnd()
3761 
      raise x
3762 
    result = addAmazonItem_result()
3763 
    result.read(self._iprot)
3764 
    self._iprot.readMessageEnd()
3765 
    return
3766 
 
7291 vikram.rag 3767 
  def getAsinItems(self, ):
3768 
    self.send_getAsinItems()
3769 
    return self.recv_getAsinItems()
7281 kshitij.so 3770 
 
7291 vikram.rag 3771 
  def send_getAsinItems(self, ):
3772 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3773 
    args = getAsinItems_args()
3774 
    args.write(self._oprot)
3775 
    self._oprot.writeMessageEnd()
3776 
    self._oprot.trans.flush()
3777 
 
3778 
  def recv_getAsinItems(self, ):
3779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3780 
    if mtype == TMessageType.EXCEPTION:
3781 
      x = TApplicationException()
3782 
      x.read(self._iprot)
3783 
      self._iprot.readMessageEnd()
3784 
      raise x
3785 
    result = getAsinItems_result()
3786 
    result.read(self._iprot)
3787 
    self._iprot.readMessageEnd()
3788 
    if result.success is not None:
3789 
      return result.success
3790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3791 
 
3792 
  def getAllFbaListedItems(self, ):
3793 
    self.send_getAllFbaListedItems()
3794 
    return self.recv_getAllFbaListedItems()
3795 
 
3796 
  def send_getAllFbaListedItems(self, ):
3797 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3798 
    args = getAllFbaListedItems_args()
3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_getAllFbaListedItems(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = getAllFbaListedItems_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.success is not None:
3814 
      return result.success
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3816 
 
3817 
  def getAllNonFbaListedItems(self, ):
3818 
    self.send_getAllNonFbaListedItems()
3819 
    return self.recv_getAllNonFbaListedItems()
3820 
 
3821 
  def send_getAllNonFbaListedItems(self, ):
3822 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3823 
    args = getAllNonFbaListedItems_args()
3824 
    args.write(self._oprot)
3825 
    self._oprot.writeMessageEnd()
3826 
    self._oprot.trans.flush()
3827 
 
3828 
  def recv_getAllNonFbaListedItems(self, ):
3829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3830 
    if mtype == TMessageType.EXCEPTION:
3831 
      x = TApplicationException()
3832 
      x.read(self._iprot)
3833 
      self._iprot.readMessageEnd()
3834 
      raise x
3835 
    result = getAllNonFbaListedItems_result()
3836 
    result.read(self._iprot)
3837 
    self._iprot.readMessageEnd()
3838 
    if result.success is not None:
3839 
      return result.success
3840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3841 
 
7460 kshitij.so 3842 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3843 
    """
3844 
    Parameters:
3845 
     - itemId
3846 
     - holdInventory
3847 
     - defaultInventory
3848 
    """
3849 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3850 
    return self.recv_updateItemInventory()
7291 vikram.rag 3851 
 
7460 kshitij.so 3852 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3853 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3854 
    args = updateItemInventory_args()
3855 
    args.itemId = itemId
3856 
    args.holdInventory = holdInventory
3857 
    args.defaultInventory = defaultInventory
3858 
    args.write(self._oprot)
3859 
    self._oprot.writeMessageEnd()
3860 
    self._oprot.trans.flush()
3861 
 
3862 
  def recv_updateItemInventory(self, ):
3863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3864 
    if mtype == TMessageType.EXCEPTION:
3865 
      x = TApplicationException()
3866 
      x.read(self._iprot)
3867 
      self._iprot.readMessageEnd()
3868 
      raise x
3869 
    result = updateItemInventory_result()
3870 
    result.read(self._iprot)
3871 
    self._iprot.readMessageEnd()
3872 
    if result.success is not None:
3873 
      return result.success
3874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3875 
 
7770 kshitij.so 3876 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3877 
    """
3878 
    Parameters:
3879 
     - type
3880 
     - sku
3881 
     - timestamp
3882 
    """
3883 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3884 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3885 
 
7770 kshitij.so 3886 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3887 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3888 
    args = updateTimestampForAmazonFeeds_args()
3889 
    args.type = type
3890 
    args.sku = sku
3891 
    args.timestamp = timestamp
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_updateTimestampForAmazonFeeds(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = updateTimestampForAmazonFeeds_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3906 
    if result.success is not None:
3907 
      return result.success
3908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3909 
 
7897 amar.kumar 3910 
  def getAllParentCategories(self, ):
3911 
    self.send_getAllParentCategories()
3912 
    return self.recv_getAllParentCategories()
7770 kshitij.so 3913 
 
7897 amar.kumar 3914 
  def send_getAllParentCategories(self, ):
3915 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
3916 
    args = getAllParentCategories_args()
3917 
    args.write(self._oprot)
3918 
    self._oprot.writeMessageEnd()
3919 
    self._oprot.trans.flush()
3920 
 
3921 
  def recv_getAllParentCategories(self, ):
3922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3923 
    if mtype == TMessageType.EXCEPTION:
3924 
      x = TApplicationException()
3925 
      x.read(self._iprot)
3926 
      self._iprot.readMessageEnd()
3927 
      raise x
3928 
    result = getAllParentCategories_result()
3929 
    result.read(self._iprot)
3930 
    self._iprot.readMessageEnd()
3931 
    if result.success is not None:
3932 
      return result.success
3933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
3934 
 
7977 kshitij.so 3935 
  def addPageViewEvent(self, pageViewEvents):
3936 
    """
3937 
    Parameters:
3938 
     - pageViewEvents
3939 
    """
3940 
    self.send_addPageViewEvent(pageViewEvents)
3941 
    self.recv_addPageViewEvent()
7897 amar.kumar 3942 
 
7977 kshitij.so 3943 
  def send_addPageViewEvent(self, pageViewEvents):
3944 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
3945 
    args = addPageViewEvent_args()
3946 
    args.pageViewEvents = pageViewEvents
3947 
    args.write(self._oprot)
3948 
    self._oprot.writeMessageEnd()
3949 
    self._oprot.trans.flush()
3950 
 
3951 
  def recv_addPageViewEvent(self, ):
3952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3953 
    if mtype == TMessageType.EXCEPTION:
3954 
      x = TApplicationException()
3955 
      x.read(self._iprot)
3956 
      self._iprot.readMessageEnd()
3957 
      raise x
3958 
    result = addPageViewEvent_result()
3959 
    result.read(self._iprot)
3960 
    self._iprot.readMessageEnd()
3961 
    return
3962 
 
3963 
  def addCartEvent(self, cartEvents):
3964 
    """
3965 
    Parameters:
3966 
     - cartEvents
3967 
    """
3968 
    self.send_addCartEvent(cartEvents)
3969 
    self.recv_addCartEvent()
3970 
 
3971 
  def send_addCartEvent(self, cartEvents):
3972 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
3973 
    args = addCartEvent_args()
3974 
    args.cartEvents = cartEvents
3975 
    args.write(self._oprot)
3976 
    self._oprot.writeMessageEnd()
3977 
    self._oprot.trans.flush()
3978 
 
3979 
  def recv_addCartEvent(self, ):
3980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3981 
    if mtype == TMessageType.EXCEPTION:
3982 
      x = TApplicationException()
3983 
      x.read(self._iprot)
3984 
      self._iprot.readMessageEnd()
3985 
      raise x
3986 
    result = addCartEvent_result()
3987 
    result.read(self._iprot)
3988 
    self._iprot.readMessageEnd()
3989 
    return
3990 
 
8139 kshitij.so 3991 
  def getAmazonListedItems(self, offset, limit):
3992 
    """
3993 
    Parameters:
3994 
     - offset
3995 
     - limit
3996 
    """
3997 
    self.send_getAmazonListedItems(offset, limit)
3998 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 3999 
 
8139 kshitij.so 4000 
  def send_getAmazonListedItems(self, offset, limit):
4001 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4002 
    args = getAmazonListedItems_args()
4003 
    args.offset = offset
4004 
    args.limit = limit
4005 
    args.write(self._oprot)
4006 
    self._oprot.writeMessageEnd()
4007 
    self._oprot.trans.flush()
4008 
 
4009 
  def recv_getAmazonListedItems(self, ):
4010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4011 
    if mtype == TMessageType.EXCEPTION:
4012 
      x = TApplicationException()
4013 
      x.read(self._iprot)
4014 
      self._iprot.readMessageEnd()
4015 
      raise x
4016 
    result = getAmazonListedItems_result()
4017 
    result.read(self._iprot)
4018 
    self._iprot.readMessageEnd()
4019 
    if result.success is not None:
4020 
      return result.success
4021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4022 
 
8168 kshitij.so 4023 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4024 
    """
4025 
    Parameters:
4026 
     - amazonlisted
4027 
    """
4028 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4029 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4030 
 
8168 kshitij.so 4031 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4032 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4033 
    args = updateAmazonAttributesInBulk_args()
4034 
    args.amazonlisted = amazonlisted
4035 
    args.write(self._oprot)
4036 
    self._oprot.writeMessageEnd()
4037 
    self._oprot.trans.flush()
4038 
 
4039 
  def recv_updateAmazonAttributesInBulk(self, ):
4040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4041 
    if mtype == TMessageType.EXCEPTION:
4042 
      x = TApplicationException()
4043 
      x.read(self._iprot)
4044 
      self._iprot.readMessageEnd()
4045 
      raise x
4046 
    result = updateAmazonAttributesInBulk_result()
4047 
    result.read(self._iprot)
4048 
    self._iprot.readMessageEnd()
4049 
    if result.success is not None:
4050 
      return result.success
4051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4052 
 
4053 
 
5944 mandeep.dh 4054 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4055 
  def __init__(self, handler):
4056 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4057 
    self._processMap["addItem"] = Processor.process_addItem
4058 
    self._processMap["updateItem"] = Processor.process_updateItem
4059 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4060 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4061 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4062 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4063 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4064 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4065 
    self._processMap["getItem"] = Processor.process_getItem
4066 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4067 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4068 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4069 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4070 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4071 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4072 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4073 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4074 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4075 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4076 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4077 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4078 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4079 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4080 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4081 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4082 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4083 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4084 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4085 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4086 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4087 
    self._processMap["addCategory"] = Processor.process_addCategory
4088 
    self._processMap["getCategory"] = Processor.process_getCategory
4089 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4090 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4091 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4092 
    self._processMap["addTag"] = Processor.process_addTag
4093 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4094 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4095 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4096 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4097 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4098 
    self._processMap["addBanner"] = Processor.process_addBanner
4099 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4100 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4101 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4102 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4103 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
4104 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4105 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 4106 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4107 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4108 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4109 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4110 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4111 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4112 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4113 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4114 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4115 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4116 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4117 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4118 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4119 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4120 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4121 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4122 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4123 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4124 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4125 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4126 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4127 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4128 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4129 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4130 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4131 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4132 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4133 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4134 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4135 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4136 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4137 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4138 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4139 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4140 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4141 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4142 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4143 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4144 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4145 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4146 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4147 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4148 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4149 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4150 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4151 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4152 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4153 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4154 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4155 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4156 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4157 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4158 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8139 kshitij.so 4159 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4160 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
5944 mandeep.dh 4161 
 
4162 
  def process(self, iprot, oprot):
4163 
    (name, type, seqid) = iprot.readMessageBegin()
4164 
    if name not in self._processMap:
4165 
      iprot.skip(TType.STRUCT)
4166 
      iprot.readMessageEnd()
4167 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4168 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4169 
      x.write(oprot)
4170 
      oprot.writeMessageEnd()
4171 
      oprot.trans.flush()
4172 
      return
4173 
    else:
4174 
      self._processMap[name](self, seqid, iprot, oprot)
4175 
    return True
4176 
 
4177 
  def process_addItem(self, seqid, iprot, oprot):
4178 
    args = addItem_args()
4179 
    args.read(iprot)
4180 
    iprot.readMessageEnd()
4181 
    result = addItem_result()
4182 
    try:
4183 
      result.success = self._handler.addItem(args.item)
4184 
    except CatalogServiceException, cex:
4185 
      result.cex = cex
4186 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4187 
    result.write(oprot)
4188 
    oprot.writeMessageEnd()
4189 
    oprot.trans.flush()
4190 
 
4191 
  def process_updateItem(self, seqid, iprot, oprot):
4192 
    args = updateItem_args()
4193 
    args.read(iprot)
4194 
    iprot.readMessageEnd()
4195 
    result = updateItem_result()
4196 
    try:
4197 
      result.success = self._handler.updateItem(args.item)
4198 
    except CatalogServiceException, cex:
4199 
      result.cex = cex
4200 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4201 
    result.write(oprot)
4202 
    oprot.writeMessageEnd()
4203 
    oprot.trans.flush()
4204 
 
4205 
  def process_isActive(self, seqid, iprot, oprot):
4206 
    args = isActive_args()
4207 
    args.read(iprot)
4208 
    iprot.readMessageEnd()
4209 
    result = isActive_result()
4210 
    try:
4211 
      result.success = self._handler.isActive(args.itemId)
4212 
    except CatalogServiceException, isex:
4213 
      result.isex = isex
4214 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4215 
    result.write(oprot)
4216 
    oprot.writeMessageEnd()
4217 
    oprot.trans.flush()
4218 
 
7438 amit.gupta 4219 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4220 
    args = getItemsStatus_args()
4221 
    args.read(iprot)
4222 
    iprot.readMessageEnd()
4223 
    result = getItemsStatus_result()
4224 
    try:
4225 
      result.success = self._handler.getItemsStatus(args.itemIds)
4226 
    except CatalogServiceException, isex:
4227 
      result.isex = isex
4228 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4229 
    result.write(oprot)
4230 
    oprot.writeMessageEnd()
4231 
    oprot.trans.flush()
4232 
 
5944 mandeep.dh 4233 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4234 
    args = getItemStatusDescription_args()
4235 
    args.read(iprot)
4236 
    iprot.readMessageEnd()
4237 
    result = getItemStatusDescription_result()
4238 
    try:
4239 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4240 
    except CatalogServiceException, isex:
4241 
      result.isex = isex
4242 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4243 
    result.write(oprot)
4244 
    oprot.writeMessageEnd()
4245 
    oprot.trans.flush()
4246 
 
4247 
  def process_startItemOn(self, seqid, iprot, oprot):
4248 
    args = startItemOn_args()
4249 
    args.read(iprot)
4250 
    iprot.readMessageEnd()
4251 
    result = startItemOn_result()
4252 
    try:
4253 
      self._handler.startItemOn(args.item_id, args.timestamp)
4254 
    except CatalogServiceException, cex:
4255 
      result.cex = cex
4256 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4257 
    result.write(oprot)
4258 
    oprot.writeMessageEnd()
4259 
    oprot.trans.flush()
4260 
 
4261 
  def process_retireItemOn(self, seqid, iprot, oprot):
4262 
    args = retireItemOn_args()
4263 
    args.read(iprot)
4264 
    iprot.readMessageEnd()
4265 
    result = retireItemOn_result()
4266 
    try:
4267 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4268 
    except CatalogServiceException, cex:
4269 
      result.cex = cex
4270 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4271 
    result.write(oprot)
4272 
    oprot.writeMessageEnd()
4273 
    oprot.trans.flush()
4274 
 
4275 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4276 
    args = changeItemStatus_args()
4277 
    args.read(iprot)
4278 
    iprot.readMessageEnd()
4279 
    result = changeItemStatus_result()
4280 
    try:
4281 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4282 
    except CatalogServiceException, cex:
4283 
      result.cex = cex
4284 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4285 
    result.write(oprot)
4286 
    oprot.writeMessageEnd()
4287 
    oprot.trans.flush()
4288 
 
4289 
  def process_getItem(self, seqid, iprot, oprot):
4290 
    args = getItem_args()
4291 
    args.read(iprot)
4292 
    iprot.readMessageEnd()
4293 
    result = getItem_result()
4294 
    try:
4295 
      result.success = self._handler.getItem(args.item_id)
4296 
    except CatalogServiceException, cex:
4297 
      result.cex = cex
4298 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4299 
    result.write(oprot)
4300 
    oprot.writeMessageEnd()
4301 
    oprot.trans.flush()
4302 
 
4303 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4304 
    args = getItemsByCatalogId_args()
4305 
    args.read(iprot)
4306 
    iprot.readMessageEnd()
4307 
    result = getItemsByCatalogId_result()
4308 
    try:
4309 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4310 
    except CatalogServiceException, cex:
4311 
      result.cex = cex
4312 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4313 
    result.write(oprot)
4314 
    oprot.writeMessageEnd()
4315 
    oprot.trans.flush()
4316 
 
4317 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4318 
    args = getValidItemsByCatalogId_args()
4319 
    args.read(iprot)
4320 
    iprot.readMessageEnd()
4321 
    result = getValidItemsByCatalogId_result()
4322 
    try:
4323 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4324 
    except CatalogServiceException, cex:
4325 
      result.cex = cex
4326 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
4330 
 
4331 
  def process_getAllItems(self, seqid, iprot, oprot):
4332 
    args = getAllItems_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = getAllItems_result()
4336 
    try:
4337 
      result.success = self._handler.getAllItems(args.isActive)
4338 
    except CatalogServiceException, cex:
4339 
      result.cex = cex
4340 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4341 
    result.write(oprot)
4342 
    oprot.writeMessageEnd()
4343 
    oprot.trans.flush()
4344 
 
4345 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4346 
    args = getAllItemsByStatus_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = getAllItemsByStatus_result()
4350 
    try:
4351 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4352 
    except CatalogServiceException, cex:
4353 
      result.cex = cex
4354 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4355 
    result.write(oprot)
4356 
    oprot.writeMessageEnd()
4357 
    oprot.trans.flush()
4358 
 
4359 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4360 
    args = markItemAsContentComplete_args()
4361 
    args.read(iprot)
4362 
    iprot.readMessageEnd()
4363 
    result = markItemAsContentComplete_result()
4364 
    try:
4365 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4366 
    except CatalogServiceException, cex:
4367 
      result.cex = cex
4368 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4369 
    result.write(oprot)
4370 
    oprot.writeMessageEnd()
4371 
    oprot.trans.flush()
4372 
 
4373 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4374 
    args = getAllItemsInRange_args()
4375 
    args.read(iprot)
4376 
    iprot.readMessageEnd()
4377 
    result = getAllItemsInRange_result()
4378 
    try:
4379 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4380 
    except CatalogServiceException, cex:
4381 
      result.cex = cex
4382 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4383 
    result.write(oprot)
4384 
    oprot.writeMessageEnd()
4385 
    oprot.trans.flush()
4386 
 
4387 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4388 
    args = getAllItemsByStatusInRange_args()
4389 
    args.read(iprot)
4390 
    iprot.readMessageEnd()
4391 
    result = getAllItemsByStatusInRange_result()
4392 
    try:
4393 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4394 
    except CatalogServiceException, cex:
4395 
      result.cex = cex
4396 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4397 
    result.write(oprot)
4398 
    oprot.writeMessageEnd()
4399 
    oprot.trans.flush()
4400 
 
4401 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4402 
    args = getItemCountByStatus_args()
4403 
    args.read(iprot)
4404 
    iprot.readMessageEnd()
4405 
    result = getItemCountByStatus_result()
4406 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4407 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4408 
    result.write(oprot)
4409 
    oprot.writeMessageEnd()
4410 
    oprot.trans.flush()
4411 
 
4412 
  def process_getBestSellers(self, seqid, iprot, oprot):
4413 
    args = getBestSellers_args()
4414 
    args.read(iprot)
4415 
    iprot.readMessageEnd()
4416 
    result = getBestSellers_result()
4417 
    try:
4418 
      result.success = self._handler.getBestSellers()
4419 
    except CatalogServiceException, isex:
4420 
      result.isex = isex
4421 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4422 
    result.write(oprot)
4423 
    oprot.writeMessageEnd()
4424 
    oprot.trans.flush()
4425 
 
4426 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4427 
    args = getBestSellersCatalogIds_args()
4428 
    args.read(iprot)
4429 
    iprot.readMessageEnd()
4430 
    result = getBestSellersCatalogIds_result()
4431 
    try:
4432 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4433 
    except CatalogServiceException, cex:
4434 
      result.cex = cex
4435 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4436 
    result.write(oprot)
4437 
    oprot.writeMessageEnd()
4438 
    oprot.trans.flush()
4439 
 
4440 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4441 
    args = getBestSellersCount_args()
4442 
    args.read(iprot)
4443 
    iprot.readMessageEnd()
4444 
    result = getBestSellersCount_result()
4445 
    try:
4446 
      result.success = self._handler.getBestSellersCount()
4447 
    except CatalogServiceException, cex:
4448 
      result.cex = cex
4449 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4450 
    result.write(oprot)
4451 
    oprot.writeMessageEnd()
4452 
    oprot.trans.flush()
4453 
 
4454 
  def process_getBestDeals(self, seqid, iprot, oprot):
4455 
    args = getBestDeals_args()
4456 
    args.read(iprot)
4457 
    iprot.readMessageEnd()
4458 
    result = getBestDeals_result()
4459 
    try:
4460 
      result.success = self._handler.getBestDeals()
4461 
    except CatalogServiceException, isex:
4462 
      result.isex = isex
4463 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4464 
    result.write(oprot)
4465 
    oprot.writeMessageEnd()
4466 
    oprot.trans.flush()
4467 
 
4468 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4469 
    args = getBestDealsCatalogIds_args()
4470 
    args.read(iprot)
4471 
    iprot.readMessageEnd()
4472 
    result = getBestDealsCatalogIds_result()
4473 
    try:
4474 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4475 
    except CatalogServiceException, cex:
4476 
      result.cex = cex
4477 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4478 
    result.write(oprot)
4479 
    oprot.writeMessageEnd()
4480 
    oprot.trans.flush()
4481 
 
4482 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4483 
    args = getBestDealsCount_args()
4484 
    args.read(iprot)
4485 
    iprot.readMessageEnd()
4486 
    result = getBestDealsCount_result()
4487 
    try:
4488 
      result.success = self._handler.getBestDealsCount()
4489 
    except CatalogServiceException, cex:
4490 
      result.cex = cex
4491 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4492 
    result.write(oprot)
4493 
    oprot.writeMessageEnd()
4494 
    oprot.trans.flush()
4495 
 
4496 
  def process_getComingSoon(self, seqid, iprot, oprot):
4497 
    args = getComingSoon_args()
4498 
    args.read(iprot)
4499 
    iprot.readMessageEnd()
4500 
    result = getComingSoon_result()
4501 
    try:
4502 
      result.success = self._handler.getComingSoon()
4503 
    except CatalogServiceException, isex:
4504 
      result.isex = isex
4505 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4506 
    result.write(oprot)
4507 
    oprot.writeMessageEnd()
4508 
    oprot.trans.flush()
4509 
 
4510 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4511 
    args = getComingSoonCatalogIds_args()
4512 
    args.read(iprot)
4513 
    iprot.readMessageEnd()
4514 
    result = getComingSoonCatalogIds_result()
4515 
    try:
4516 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4517 
    except CatalogServiceException, cex:
4518 
      result.cex = cex
4519 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4520 
    result.write(oprot)
4521 
    oprot.writeMessageEnd()
4522 
    oprot.trans.flush()
4523 
 
4524 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4525 
    args = getComingSoonCount_args()
4526 
    args.read(iprot)
4527 
    iprot.readMessageEnd()
4528 
    result = getComingSoonCount_result()
4529 
    try:
4530 
      result.success = self._handler.getComingSoonCount()
4531 
    except CatalogServiceException, cex:
4532 
      result.cex = cex
4533 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4534 
    result.write(oprot)
4535 
    oprot.writeMessageEnd()
4536 
    oprot.trans.flush()
4537 
 
4538 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4539 
    args = getLatestArrivals_args()
4540 
    args.read(iprot)
4541 
    iprot.readMessageEnd()
4542 
    result = getLatestArrivals_result()
4543 
    try:
4544 
      result.success = self._handler.getLatestArrivals()
4545 
    except CatalogServiceException, isex:
4546 
      result.isex = isex
4547 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
4551 
 
4552 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4553 
    args = getLatestArrivalsCatalogIds_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = getLatestArrivalsCatalogIds_result()
4557 
    try:
4558 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4559 
    except CatalogServiceException, cex:
4560 
      result.cex = cex
4561 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
4565 
 
4566 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4567 
    args = getLatestArrivalsCount_args()
4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
4570 
    result = getLatestArrivalsCount_result()
4571 
    try:
4572 
      result.success = self._handler.getLatestArrivalsCount()
4573 
    except CatalogServiceException, cex:
4574 
      result.cex = cex
4575 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4576 
    result.write(oprot)
4577 
    oprot.writeMessageEnd()
4578 
    oprot.trans.flush()
4579 
 
4580 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4581 
    args = generateNewEntityID_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = generateNewEntityID_result()
4585 
    result.success = self._handler.generateNewEntityID()
4586 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4587 
    result.write(oprot)
4588 
    oprot.writeMessageEnd()
4589 
    oprot.trans.flush()
4590 
 
4591 
  def process_addCategory(self, seqid, iprot, oprot):
4592 
    args = addCategory_args()
4593 
    args.read(iprot)
4594 
    iprot.readMessageEnd()
4595 
    result = addCategory_result()
4596 
    result.success = self._handler.addCategory(args.category)
4597 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4598 
    result.write(oprot)
4599 
    oprot.writeMessageEnd()
4600 
    oprot.trans.flush()
4601 
 
4602 
  def process_getCategory(self, seqid, iprot, oprot):
4603 
    args = getCategory_args()
4604 
    args.read(iprot)
4605 
    iprot.readMessageEnd()
4606 
    result = getCategory_result()
4607 
    result.success = self._handler.getCategory(args.id)
4608 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4609 
    result.write(oprot)
4610 
    oprot.writeMessageEnd()
4611 
    oprot.trans.flush()
4612 
 
4613 
  def process_getAllCategories(self, seqid, iprot, oprot):
4614 
    args = getAllCategories_args()
4615 
    args.read(iprot)
4616 
    iprot.readMessageEnd()
4617 
    result = getAllCategories_result()
4618 
    result.success = self._handler.getAllCategories()
4619 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4620 
    result.write(oprot)
4621 
    oprot.writeMessageEnd()
4622 
    oprot.trans.flush()
4623 
 
4624 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4625 
    args = getAllSimilarItems_args()
4626 
    args.read(iprot)
4627 
    iprot.readMessageEnd()
4628 
    result = getAllSimilarItems_result()
4629 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4630 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4631 
    result.write(oprot)
4632 
    oprot.writeMessageEnd()
4633 
    oprot.trans.flush()
4634 
 
4635 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4636 
    args = addSimilarItem_args()
4637 
    args.read(iprot)
4638 
    iprot.readMessageEnd()
4639 
    result = addSimilarItem_result()
4640 
    try:
4641 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4642 
    except CatalogServiceException, cex:
4643 
      result.cex = cex
4644 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4645 
    result.write(oprot)
4646 
    oprot.writeMessageEnd()
4647 
    oprot.trans.flush()
4648 
 
6512 kshitij.so 4649 
  def process_addTag(self, seqid, iprot, oprot):
4650 
    args = addTag_args()
4651 
    args.read(iprot)
4652 
    iprot.readMessageEnd()
4653 
    result = addTag_result()
4654 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4655 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4656 
    result.write(oprot)
4657 
    oprot.writeMessageEnd()
4658 
    oprot.trans.flush()
4659 
 
4660 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4661 
    args = deleteEntityTag_args()
4662 
    args.read(iprot)
4663 
    iprot.readMessageEnd()
4664 
    result = deleteEntityTag_result()
4665 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4666 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4667 
    result.write(oprot)
4668 
    oprot.writeMessageEnd()
4669 
    oprot.trans.flush()
4670 
 
4671 
  def process_deleteTag(self, seqid, iprot, oprot):
4672 
    args = deleteTag_args()
4673 
    args.read(iprot)
4674 
    iprot.readMessageEnd()
4675 
    result = deleteTag_result()
4676 
    result.success = self._handler.deleteTag(args.displayName)
4677 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4678 
    result.write(oprot)
4679 
    oprot.writeMessageEnd()
4680 
    oprot.trans.flush()
4681 
 
4682 
  def process_getAllTags(self, seqid, iprot, oprot):
4683 
    args = getAllTags_args()
4684 
    args.read(iprot)
4685 
    iprot.readMessageEnd()
4686 
    result = getAllTags_result()
4687 
    result.success = self._handler.getAllTags()
4688 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4689 
    result.write(oprot)
4690 
    oprot.writeMessageEnd()
4691 
    oprot.trans.flush()
4692 
 
4693 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4694 
    args = getAllEntitiesByTagName_args()
4695 
    args.read(iprot)
4696 
    iprot.readMessageEnd()
4697 
    result = getAllEntitiesByTagName_result()
4698 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4699 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4700 
    result.write(oprot)
4701 
    oprot.writeMessageEnd()
4702 
    oprot.trans.flush()
4703 
 
6845 amit.gupta 4704 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4705 
    args = getAllEntityTags_args()
4706 
    args.read(iprot)
4707 
    iprot.readMessageEnd()
4708 
    result = getAllEntityTags_result()
4709 
    result.success = self._handler.getAllEntityTags()
4710 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4711 
    result.write(oprot)
4712 
    oprot.writeMessageEnd()
4713 
    oprot.trans.flush()
4714 
 
6850 kshitij.so 4715 
  def process_addBanner(self, seqid, iprot, oprot):
4716 
    args = addBanner_args()
4717 
    args.read(iprot)
4718 
    iprot.readMessageEnd()
4719 
    result = addBanner_result()
4720 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4721 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4722 
    result.write(oprot)
4723 
    oprot.writeMessageEnd()
4724 
    oprot.trans.flush()
4725 
 
4726 
  def process_getAllBanners(self, seqid, iprot, oprot):
4727 
    args = getAllBanners_args()
4728 
    args.read(iprot)
4729 
    iprot.readMessageEnd()
4730 
    result = getAllBanners_result()
4731 
    result.success = self._handler.getAllBanners()
4732 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4733 
    result.write(oprot)
4734 
    oprot.writeMessageEnd()
4735 
    oprot.trans.flush()
4736 
 
4737 
  def process_deleteBanner(self, seqid, iprot, oprot):
4738 
    args = deleteBanner_args()
4739 
    args.read(iprot)
4740 
    iprot.readMessageEnd()
4741 
    result = deleteBanner_result()
4742 
    result.success = self._handler.deleteBanner(args.bannerName)
4743 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
4748 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4749 
    args = getBannerDetails_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = getBannerDetails_result()
4753 
    result.success = self._handler.getBannerDetails(args.bannerName)
4754 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
4759 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4760 
    args = getActiveBanners_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = getActiveBanners_result()
4764 
    result.success = self._handler.getActiveBanners()
4765 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
6849 kshitij.so 4770 
  def process_addBannerMap(self, seqid, iprot, oprot):
4771 
    args = addBannerMap_args()
4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
4774 
    result = addBannerMap_result()
4775 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4776 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4777 
    result.write(oprot)
4778 
    oprot.writeMessageEnd()
4779 
    oprot.trans.flush()
4780 
 
4781 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4782 
    args = deleteBannerMap_args()
4783 
    args.read(iprot)
4784 
    iprot.readMessageEnd()
4785 
    result = deleteBannerMap_result()
4786 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4787 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
4792 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4793 
    args = getBannerMapDetails_args()
4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
4796 
    result = getBannerMapDetails_result()
4797 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4798 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
5944 mandeep.dh 4803 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4804 
    args = deleteSimilarItem_args()
4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
4807 
    result = deleteSimilarItem_result()
4808 
    try:
4809 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4810 
    except CatalogServiceException, cex:
4811 
      result.cex = cex
4812 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
4817 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4818 
    args = checkSimilarItem_args()
4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
4821 
    result = checkSimilarItem_result()
4822 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4823 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4824 
    result.write(oprot)
4825 
    oprot.writeMessageEnd()
4826 
    oprot.trans.flush()
4827 
 
4828 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4829 
    args = validateRiskyStatus_args()
4830 
    args.read(iprot)
4831 
    iprot.readMessageEnd()
4832 
    result = validateRiskyStatus_result()
4833 
    self._handler.validateRiskyStatus(args.itemId)
4834 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4835 
    result.write(oprot)
4836 
    oprot.writeMessageEnd()
4837 
    oprot.trans.flush()
4838 
 
4839 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4840 
    args = changeItemRiskyFlag_args()
4841 
    args.read(iprot)
4842 
    iprot.readMessageEnd()
4843 
    result = changeItemRiskyFlag_result()
4844 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4845 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4846 
    result.write(oprot)
4847 
    oprot.writeMessageEnd()
4848 
    oprot.trans.flush()
4849 
 
4850 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4851 
    args = getItemsByRiskyFlag_args()
4852 
    args.read(iprot)
4853 
    iprot.readMessageEnd()
4854 
    result = getItemsByRiskyFlag_result()
4855 
    result.success = self._handler.getItemsByRiskyFlag()
4856 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4857 
    result.write(oprot)
4858 
    oprot.writeMessageEnd()
4859 
    oprot.trans.flush()
4860 
 
4861 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4862 
    args = getItemsForMasterSheet_args()
4863 
    args.read(iprot)
4864 
    iprot.readMessageEnd()
4865 
    result = getItemsForMasterSheet_result()
4866 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4867 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
4871 
 
4872 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4873 
    args = getSimilarItemsCatalogIds_args()
4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
4876 
    result = getSimilarItemsCatalogIds_result()
4877 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4878 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4879 
    result.write(oprot)
4880 
    oprot.writeMessageEnd()
4881 
    oprot.trans.flush()
4882 
 
4883 
  def process_addProductNotification(self, seqid, iprot, oprot):
4884 
    args = addProductNotification_args()
4885 
    args.read(iprot)
4886 
    iprot.readMessageEnd()
4887 
    result = addProductNotification_result()
4888 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4889 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
4893 
 
4894 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4895 
    args = sendProductNotifications_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = sendProductNotifications_result()
4899 
    result.success = self._handler.sendProductNotifications()
4900 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
4904 
 
4905 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4906 
    args = getAllBrandsByCategory_args()
4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
4909 
    result = getAllBrandsByCategory_result()
4910 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4911 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
4916 
  def process_getAllBrands(self, seqid, iprot, oprot):
4917 
    args = getAllBrands_args()
4918 
    args.read(iprot)
4919 
    iprot.readMessageEnd()
4920 
    result = getAllBrands_result()
4921 
    result.success = self._handler.getAllBrands()
4922 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4923 
    result.write(oprot)
4924 
    oprot.writeMessageEnd()
4925 
    oprot.trans.flush()
4926 
 
4927 
  def process_getAllSources(self, seqid, iprot, oprot):
4928 
    args = getAllSources_args()
4929 
    args.read(iprot)
4930 
    iprot.readMessageEnd()
4931 
    result = getAllSources_result()
4932 
    result.success = self._handler.getAllSources()
4933 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
4937 
 
4938 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4939 
    args = getItemPricingBySource_args()
4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
4942 
    result = getItemPricingBySource_result()
4943 
    try:
4944 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4945 
    except CatalogServiceException, cex:
4946 
      result.cex = cex
4947 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4948 
    result.write(oprot)
4949 
    oprot.writeMessageEnd()
4950 
    oprot.trans.flush()
4951 
 
4952 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4953 
    args = addSourceItemPricing_args()
4954 
    args.read(iprot)
4955 
    iprot.readMessageEnd()
4956 
    result = addSourceItemPricing_result()
4957 
    try:
4958 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4959 
    except CatalogServiceException, cex:
4960 
      result.cex = cex
4961 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4962 
    result.write(oprot)
4963 
    oprot.writeMessageEnd()
4964 
    oprot.trans.flush()
4965 
 
4966 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4967 
    args = getAllSourcePricing_args()
4968 
    args.read(iprot)
4969 
    iprot.readMessageEnd()
4970 
    result = getAllSourcePricing_result()
4971 
    try:
4972 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4973 
    except CatalogServiceException, cex:
4974 
      result.cex = cex
4975 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
4979 
 
4980 
  def process_getItemForSource(self, seqid, iprot, oprot):
4981 
    args = getItemForSource_args()
4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
4984 
    result = getItemForSource_result()
4985 
    try:
4986 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4987 
    except CatalogServiceException, cex:
4988 
      result.cex = cex
4989 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4990 
    result.write(oprot)
4991 
    oprot.writeMessageEnd()
4992 
    oprot.trans.flush()
4993 
 
4994 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4995 
    args = searchItemsInRange_args()
4996 
    args.read(iprot)
4997 
    iprot.readMessageEnd()
4998 
    result = searchItemsInRange_result()
4999 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5000 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5001 
    result.write(oprot)
5002 
    oprot.writeMessageEnd()
5003 
    oprot.trans.flush()
5004 
 
5005 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5006 
    args = getSearchResultCount_args()
5007 
    args.read(iprot)
5008 
    iprot.readMessageEnd()
5009 
    result = getSearchResultCount_result()
5010 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5011 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5012 
    result.write(oprot)
5013 
    oprot.writeMessageEnd()
5014 
    oprot.trans.flush()
5015 
 
5016 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5017 
    args = getProductNotifications_args()
5018 
    args.read(iprot)
5019 
    iprot.readMessageEnd()
5020 
    result = getProductNotifications_result()
5021 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5022 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5023 
    result.write(oprot)
5024 
    oprot.writeMessageEnd()
5025 
    oprot.trans.flush()
5026 
 
5027 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5028 
    args = getProductNotificationRequestCount_args()
5029 
    args.read(iprot)
5030 
    iprot.readMessageEnd()
5031 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5032 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5033 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5034 
    result.write(oprot)
5035 
    oprot.writeMessageEnd()
5036 
    oprot.trans.flush()
5037 
 
5038 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5039 
    args = addAuthorizationLog_args()
5040 
    args.read(iprot)
5041 
    iprot.readMessageEnd()
5042 
    result = addAuthorizationLog_result()
5043 
    try:
5044 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5045 
    except CatalogServiceException, cex:
5046 
      result.cex = cex
5047 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5048 
    result.write(oprot)
5049 
    oprot.writeMessageEnd()
5050 
    oprot.trans.flush()
5051 
 
5052 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5053 
    args = addupdateVoucherForItem_args()
5054 
    args.read(iprot)
5055 
    iprot.readMessageEnd()
5056 
    result = addupdateVoucherForItem_result()
5057 
    try:
5058 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5059 
    except CatalogServiceException, cex:
5060 
      result.cex = cex
5061 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5062 
    result.write(oprot)
5063 
    oprot.writeMessageEnd()
5064 
    oprot.trans.flush()
5065 
 
5066 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5067 
    args = deleteVoucherForItem_args()
5068 
    args.read(iprot)
5069 
    iprot.readMessageEnd()
5070 
    result = deleteVoucherForItem_result()
5071 
    try:
5072 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5073 
    except CatalogServiceException, cex:
5074 
      result.cex = cex
5075 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
5079 
 
5080 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5081 
    args = getVoucherAmount_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = getVoucherAmount_result()
5085 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5086 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
5090 
 
5091 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5092 
    args = getAllItemVouchers_args()
5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
5095 
    result = getAllItemVouchers_result()
5096 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5097 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
5101 
 
5102 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5103 
    args = isValidCatalogItemId_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = isValidCatalogItemId_result()
5107 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5108 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5109 
    result.write(oprot)
5110 
    oprot.writeMessageEnd()
5111 
    oprot.trans.flush()
5112 
 
6039 amit.gupta 5113 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5114 
    args = getVatPercentageForItem_args()
5115 
    args.read(iprot)
5116 
    iprot.readMessageEnd()
5117 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5118 
    try:
5119 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5120 
    except CatalogServiceException, cex:
5121 
      result.cex = cex
6039 amit.gupta 5122 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5123 
    result.write(oprot)
5124 
    oprot.writeMessageEnd()
5125 
    oprot.trans.flush()
5944 mandeep.dh 5126 
 
6039 amit.gupta 5127 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5128 
    args = getVatAmountForItem_args()
5129 
    args.read(iprot)
5130 
    iprot.readMessageEnd()
5131 
    result = getVatAmountForItem_result()
5132 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5133 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5134 
    result.write(oprot)
5135 
    oprot.writeMessageEnd()
5136 
    oprot.trans.flush()
5137 
 
6531 vikram.rag 5138 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5139 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5143 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5144 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5145 
    result.write(oprot)
5146 
    oprot.writeMessageEnd()
5147 
    oprot.trans.flush()
6039 amit.gupta 5148 
 
6821 amar.kumar 5149 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5150 
    args = getAllAliveItems_args()
5151 
    args.read(iprot)
5152 
    iprot.readMessageEnd()
5153 
    result = getAllAliveItems_result()
5154 
    result.success = self._handler.getAllAliveItems()
5155 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5156 
    result.write(oprot)
5157 
    oprot.writeMessageEnd()
5158 
    oprot.trans.flush()
5159 
 
6805 anupam.sin 5160 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5161 
    args = getInsuranceAmount_args()
5162 
    args.read(iprot)
5163 
    iprot.readMessageEnd()
5164 
    result = getInsuranceAmount_result()
6921 anupam.sin 5165 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5166 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5167 
    result.write(oprot)
5168 
    oprot.writeMessageEnd()
5169 
    oprot.trans.flush()
6531 vikram.rag 5170 
 
6805 anupam.sin 5171 
  def process_getInsurer(self, seqid, iprot, oprot):
5172 
    args = getInsurer_args()
5173 
    args.read(iprot)
5174 
    iprot.readMessageEnd()
5175 
    result = getInsurer_result()
5176 
    result.success = self._handler.getInsurer(args.insurerId)
5177 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5178 
    result.write(oprot)
5179 
    oprot.writeMessageEnd()
5180 
    oprot.trans.flush()
5181 
 
6838 vikram.rag 5182 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5183 
    args = getAllInsurers_args()
5184 
    args.read(iprot)
5185 
    iprot.readMessageEnd()
5186 
    result = getAllInsurers_result()
5187 
    result.success = self._handler.getAllInsurers()
5188 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5189 
    result.write(oprot)
5190 
    oprot.writeMessageEnd()
5191 
    oprot.trans.flush()
6805 anupam.sin 5192 
 
6962 rajveer 5193 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5194 
    args = updateInsuranceDeclaredAmount_args()
5195 
    args.read(iprot)
5196 
    iprot.readMessageEnd()
5197 
    result = updateInsuranceDeclaredAmount_result()
5198 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5199 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5200 
    result.write(oprot)
5201 
    oprot.writeMessageEnd()
5202 
    oprot.trans.flush()
6838 vikram.rag 5203 
 
7190 amar.kumar 5204 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5205 
    args = getFreebieForItem_args()
5206 
    args.read(iprot)
5207 
    iprot.readMessageEnd()
5208 
    result = getFreebieForItem_result()
5209 
    result.success = self._handler.getFreebieForItem(args.itemId)
5210 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5211 
    result.write(oprot)
5212 
    oprot.writeMessageEnd()
5213 
    oprot.trans.flush()
6962 rajveer 5214 
 
7190 amar.kumar 5215 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5216 
    args = addOrUpdateFreebieForItem_args()
5217 
    args.read(iprot)
5218 
    iprot.readMessageEnd()
5219 
    result = addOrUpdateFreebieForItem_result()
5220 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5221 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5222 
    result.write(oprot)
5223 
    oprot.writeMessageEnd()
5224 
    oprot.trans.flush()
5225 
 
7272 amit.gupta 5226 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5227 
    args = addOrUpdateBrandInfo_args()
5228 
    args.read(iprot)
5229 
    iprot.readMessageEnd()
5230 
    result = addOrUpdateBrandInfo_result()
5231 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5232 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5233 
    result.write(oprot)
5234 
    oprot.writeMessageEnd()
5235 
    oprot.trans.flush()
5236 
 
5237 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5238 
    args = getBrandInfo_args()
5239 
    args.read(iprot)
5240 
    iprot.readMessageEnd()
5241 
    result = getBrandInfo_result()
5242 
    result.success = self._handler.getBrandInfo()
5243 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5244 
    result.write(oprot)
5245 
    oprot.writeMessageEnd()
5246 
    oprot.trans.flush()
5247 
 
7256 rajveer 5248 
  def process_getStorePricing(self, seqid, iprot, oprot):
5249 
    args = getStorePricing_args()
5250 
    args.read(iprot)
5251 
    iprot.readMessageEnd()
5252 
    result = getStorePricing_result()
5253 
    result.success = self._handler.getStorePricing(args.itemId)
5254 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5255 
    result.write(oprot)
5256 
    oprot.writeMessageEnd()
5257 
    oprot.trans.flush()
7190 amar.kumar 5258 
 
7306 rajveer 5259 
  def process_getStorePricings(self, seqid, iprot, oprot):
5260 
    args = getStorePricings_args()
5261 
    args.read(iprot)
5262 
    iprot.readMessageEnd()
5263 
    result = getStorePricings_result()
5264 
    result.success = self._handler.getStorePricings(args.itemIds)
5265 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
7265 rajveer 5270 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5271 
    args = updateStorePricing_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = updateStorePricing_result()
7382 rajveer 5275 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5276 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
7256 rajveer 5280 
 
7281 kshitij.so 5281 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5282 
    args = getAllAmazonListedItems_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = getAllAmazonListedItems_result()
5286 
    result.success = self._handler.getAllAmazonListedItems()
5287 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
7265 rajveer 5291 
 
7281 kshitij.so 5292 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5293 
    args = getAmazonItemDetails_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = getAmazonItemDetails_result()
5297 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5298 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
5302 
 
5303 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5304 
    args = updateAmazonItemDetails_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 5308 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 5309 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
5313 
 
5314 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5315 
    args = addAmazonItem_args()
5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
5318 
    result = addAmazonItem_result()
5319 
    self._handler.addAmazonItem(args.amazonlisted)
5320 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
5324 
 
7291 vikram.rag 5325 
  def process_getAsinItems(self, seqid, iprot, oprot):
5326 
    args = getAsinItems_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = getAsinItems_result()
5330 
    result.success = self._handler.getAsinItems()
5331 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5332 
    result.write(oprot)
5333 
    oprot.writeMessageEnd()
5334 
    oprot.trans.flush()
7281 kshitij.so 5335 
 
7291 vikram.rag 5336 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5337 
    args = getAllFbaListedItems_args()
5338 
    args.read(iprot)
5339 
    iprot.readMessageEnd()
5340 
    result = getAllFbaListedItems_result()
5341 
    result.success = self._handler.getAllFbaListedItems()
5342 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5343 
    result.write(oprot)
5344 
    oprot.writeMessageEnd()
5345 
    oprot.trans.flush()
5346 
 
5347 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5348 
    args = getAllNonFbaListedItems_args()
5349 
    args.read(iprot)
5350 
    iprot.readMessageEnd()
5351 
    result = getAllNonFbaListedItems_result()
5352 
    result.success = self._handler.getAllNonFbaListedItems()
5353 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5354 
    result.write(oprot)
5355 
    oprot.writeMessageEnd()
5356 
    oprot.trans.flush()
5357 
 
7460 kshitij.so 5358 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5359 
    args = updateItemInventory_args()
5360 
    args.read(iprot)
5361 
    iprot.readMessageEnd()
5362 
    result = updateItemInventory_result()
5363 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5364 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5365 
    result.write(oprot)
5366 
    oprot.writeMessageEnd()
5367 
    oprot.trans.flush()
7291 vikram.rag 5368 
 
7770 kshitij.so 5369 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5370 
    args = updateTimestampForAmazonFeeds_args()
5371 
    args.read(iprot)
5372 
    iprot.readMessageEnd()
5373 
    result = updateTimestampForAmazonFeeds_result()
5374 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5375 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5376 
    result.write(oprot)
5377 
    oprot.writeMessageEnd()
5378 
    oprot.trans.flush()
7460 kshitij.so 5379 
 
7897 amar.kumar 5380 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5381 
    args = getAllParentCategories_args()
5382 
    args.read(iprot)
5383 
    iprot.readMessageEnd()
5384 
    result = getAllParentCategories_result()
5385 
    result.success = self._handler.getAllParentCategories()
5386 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5387 
    result.write(oprot)
5388 
    oprot.writeMessageEnd()
5389 
    oprot.trans.flush()
7770 kshitij.so 5390 
 
7977 kshitij.so 5391 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5392 
    args = addPageViewEvent_args()
5393 
    args.read(iprot)
5394 
    iprot.readMessageEnd()
5395 
    result = addPageViewEvent_result()
5396 
    self._handler.addPageViewEvent(args.pageViewEvents)
5397 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5398 
    result.write(oprot)
5399 
    oprot.writeMessageEnd()
5400 
    oprot.trans.flush()
7897 amar.kumar 5401 
 
7977 kshitij.so 5402 
  def process_addCartEvent(self, seqid, iprot, oprot):
5403 
    args = addCartEvent_args()
5404 
    args.read(iprot)
5405 
    iprot.readMessageEnd()
5406 
    result = addCartEvent_result()
5407 
    self._handler.addCartEvent(args.cartEvents)
5408 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5409 
    result.write(oprot)
5410 
    oprot.writeMessageEnd()
5411 
    oprot.trans.flush()
5412 
 
8139 kshitij.so 5413 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
5414 
    args = getAmazonListedItems_args()
5415 
    args.read(iprot)
5416 
    iprot.readMessageEnd()
5417 
    result = getAmazonListedItems_result()
5418 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
5419 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
5420 
    result.write(oprot)
5421 
    oprot.writeMessageEnd()
5422 
    oprot.trans.flush()
7977 kshitij.so 5423 
 
8168 kshitij.so 5424 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
5425 
    args = updateAmazonAttributesInBulk_args()
5426 
    args.read(iprot)
5427 
    iprot.readMessageEnd()
5428 
    result = updateAmazonAttributesInBulk_result()
5429 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
5430 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
5431 
    result.write(oprot)
5432 
    oprot.writeMessageEnd()
5433 
    oprot.trans.flush()
8139 kshitij.so 5434 
 
8168 kshitij.so 5435 
 
5944 mandeep.dh 5436 
# HELPER FUNCTIONS AND STRUCTURES
5437 
 
5438 
class addItem_args:
5439 
  """
5440 
  Attributes:
5441 
   - item
5442 
  """
5443 
 
5444 
  thrift_spec = (
5445 
    None, # 0
5446 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5447 
  )
5448 
 
5449 
  def __init__(self, item=None,):
5450 
    self.item = item
5451 
 
5452 
  def read(self, iprot):
5453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5455 
      return
5456 
    iprot.readStructBegin()
5457 
    while True:
5458 
      (fname, ftype, fid) = iprot.readFieldBegin()
5459 
      if ftype == TType.STOP:
5460 
        break
5461 
      if fid == 1:
5462 
        if ftype == TType.STRUCT:
5463 
          self.item = Item()
5464 
          self.item.read(iprot)
5465 
        else:
5466 
          iprot.skip(ftype)
5467 
      else:
5468 
        iprot.skip(ftype)
5469 
      iprot.readFieldEnd()
5470 
    iprot.readStructEnd()
5471 
 
5472 
  def write(self, oprot):
5473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5475 
      return
5476 
    oprot.writeStructBegin('addItem_args')
5477 
    if self.item is not None:
5478 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5479 
      self.item.write(oprot)
5480 
      oprot.writeFieldEnd()
5481 
    oprot.writeFieldStop()
5482 
    oprot.writeStructEnd()
5483 
 
5484 
  def validate(self):
5485 
    return
5486 
 
5487 
 
5488 
  def __repr__(self):
5489 
    L = ['%s=%r' % (key, value)
5490 
      for key, value in self.__dict__.iteritems()]
5491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5492 
 
5493 
  def __eq__(self, other):
5494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5495 
 
5496 
  def __ne__(self, other):
5497 
    return not (self == other)
5498 
 
5499 
class addItem_result:
5500 
  """
5501 
  Attributes:
5502 
   - success
5503 
   - cex
5504 
  """
5505 
 
5506 
  thrift_spec = (
5507 
    (0, TType.I64, 'success', None, None, ), # 0
5508 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5509 
  )
5510 
 
5511 
  def __init__(self, success=None, cex=None,):
5512 
    self.success = success
5513 
    self.cex = cex
5514 
 
5515 
  def read(self, iprot):
5516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5518 
      return
5519 
    iprot.readStructBegin()
5520 
    while True:
5521 
      (fname, ftype, fid) = iprot.readFieldBegin()
5522 
      if ftype == TType.STOP:
5523 
        break
5524 
      if fid == 0:
5525 
        if ftype == TType.I64:
5526 
          self.success = iprot.readI64();
5527 
        else:
5528 
          iprot.skip(ftype)
5529 
      elif fid == 1:
5530 
        if ftype == TType.STRUCT:
5531 
          self.cex = CatalogServiceException()
5532 
          self.cex.read(iprot)
5533 
        else:
5534 
          iprot.skip(ftype)
5535 
      else:
5536 
        iprot.skip(ftype)
5537 
      iprot.readFieldEnd()
5538 
    iprot.readStructEnd()
5539 
 
5540 
  def write(self, oprot):
5541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5543 
      return
5544 
    oprot.writeStructBegin('addItem_result')
5545 
    if self.success is not None:
5546 
      oprot.writeFieldBegin('success', TType.I64, 0)
5547 
      oprot.writeI64(self.success)
5548 
      oprot.writeFieldEnd()
5549 
    if self.cex is not None:
5550 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5551 
      self.cex.write(oprot)
5552 
      oprot.writeFieldEnd()
5553 
    oprot.writeFieldStop()
5554 
    oprot.writeStructEnd()
5555 
 
5556 
  def validate(self):
5557 
    return
5558 
 
5559 
 
5560 
  def __repr__(self):
5561 
    L = ['%s=%r' % (key, value)
5562 
      for key, value in self.__dict__.iteritems()]
5563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5564 
 
5565 
  def __eq__(self, other):
5566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5567 
 
5568 
  def __ne__(self, other):
5569 
    return not (self == other)
5570 
 
5571 
class updateItem_args:
5572 
  """
5573 
  Attributes:
5574 
   - item
5575 
  """
5576 
 
5577 
  thrift_spec = (
5578 
    None, # 0
5579 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5580 
  )
5581 
 
5582 
  def __init__(self, item=None,):
5583 
    self.item = item
5584 
 
5585 
  def read(self, iprot):
5586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5588 
      return
5589 
    iprot.readStructBegin()
5590 
    while True:
5591 
      (fname, ftype, fid) = iprot.readFieldBegin()
5592 
      if ftype == TType.STOP:
5593 
        break
5594 
      if fid == 1:
5595 
        if ftype == TType.STRUCT:
5596 
          self.item = Item()
5597 
          self.item.read(iprot)
5598 
        else:
5599 
          iprot.skip(ftype)
5600 
      else:
5601 
        iprot.skip(ftype)
5602 
      iprot.readFieldEnd()
5603 
    iprot.readStructEnd()
5604 
 
5605 
  def write(self, oprot):
5606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5608 
      return
5609 
    oprot.writeStructBegin('updateItem_args')
5610 
    if self.item is not None:
5611 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5612 
      self.item.write(oprot)
5613 
      oprot.writeFieldEnd()
5614 
    oprot.writeFieldStop()
5615 
    oprot.writeStructEnd()
5616 
 
5617 
  def validate(self):
5618 
    return
5619 
 
5620 
 
5621 
  def __repr__(self):
5622 
    L = ['%s=%r' % (key, value)
5623 
      for key, value in self.__dict__.iteritems()]
5624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5625 
 
5626 
  def __eq__(self, other):
5627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5628 
 
5629 
  def __ne__(self, other):
5630 
    return not (self == other)
5631 
 
5632 
class updateItem_result:
5633 
  """
5634 
  Attributes:
5635 
   - success
5636 
   - cex
5637 
  """
5638 
 
5639 
  thrift_spec = (
5640 
    (0, TType.I64, 'success', None, None, ), # 0
5641 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5642 
  )
5643 
 
5644 
  def __init__(self, success=None, cex=None,):
5645 
    self.success = success
5646 
    self.cex = cex
5647 
 
5648 
  def read(self, iprot):
5649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5651 
      return
5652 
    iprot.readStructBegin()
5653 
    while True:
5654 
      (fname, ftype, fid) = iprot.readFieldBegin()
5655 
      if ftype == TType.STOP:
5656 
        break
5657 
      if fid == 0:
5658 
        if ftype == TType.I64:
5659 
          self.success = iprot.readI64();
5660 
        else:
5661 
          iprot.skip(ftype)
5662 
      elif fid == 1:
5663 
        if ftype == TType.STRUCT:
5664 
          self.cex = CatalogServiceException()
5665 
          self.cex.read(iprot)
5666 
        else:
5667 
          iprot.skip(ftype)
5668 
      else:
5669 
        iprot.skip(ftype)
5670 
      iprot.readFieldEnd()
5671 
    iprot.readStructEnd()
5672 
 
5673 
  def write(self, oprot):
5674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5676 
      return
5677 
    oprot.writeStructBegin('updateItem_result')
5678 
    if self.success is not None:
5679 
      oprot.writeFieldBegin('success', TType.I64, 0)
5680 
      oprot.writeI64(self.success)
5681 
      oprot.writeFieldEnd()
5682 
    if self.cex is not None:
5683 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5684 
      self.cex.write(oprot)
5685 
      oprot.writeFieldEnd()
5686 
    oprot.writeFieldStop()
5687 
    oprot.writeStructEnd()
5688 
 
5689 
  def validate(self):
5690 
    return
5691 
 
5692 
 
5693 
  def __repr__(self):
5694 
    L = ['%s=%r' % (key, value)
5695 
      for key, value in self.__dict__.iteritems()]
5696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5697 
 
5698 
  def __eq__(self, other):
5699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5700 
 
5701 
  def __ne__(self, other):
5702 
    return not (self == other)
5703 
 
5704 
class isActive_args:
5705 
  """
5706 
  Attributes:
5707 
   - itemId
5708 
  """
5709 
 
5710 
  thrift_spec = (
5711 
    None, # 0
5712 
    (1, TType.I64, 'itemId', None, None, ), # 1
5713 
  )
5714 
 
5715 
  def __init__(self, itemId=None,):
5716 
    self.itemId = itemId
5717 
 
5718 
  def read(self, iprot):
5719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5721 
      return
5722 
    iprot.readStructBegin()
5723 
    while True:
5724 
      (fname, ftype, fid) = iprot.readFieldBegin()
5725 
      if ftype == TType.STOP:
5726 
        break
5727 
      if fid == 1:
5728 
        if ftype == TType.I64:
5729 
          self.itemId = iprot.readI64();
5730 
        else:
5731 
          iprot.skip(ftype)
5732 
      else:
5733 
        iprot.skip(ftype)
5734 
      iprot.readFieldEnd()
5735 
    iprot.readStructEnd()
5736 
 
5737 
  def write(self, oprot):
5738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5740 
      return
5741 
    oprot.writeStructBegin('isActive_args')
5742 
    if self.itemId is not None:
5743 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5744 
      oprot.writeI64(self.itemId)
5745 
      oprot.writeFieldEnd()
5746 
    oprot.writeFieldStop()
5747 
    oprot.writeStructEnd()
5748 
 
5749 
  def validate(self):
5750 
    return
5751 
 
5752 
 
5753 
  def __repr__(self):
5754 
    L = ['%s=%r' % (key, value)
5755 
      for key, value in self.__dict__.iteritems()]
5756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5757 
 
5758 
  def __eq__(self, other):
5759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5760 
 
5761 
  def __ne__(self, other):
5762 
    return not (self == other)
5763 
 
5764 
class isActive_result:
5765 
  """
5766 
  Attributes:
5767 
   - success
5768 
   - isex
5769 
  """
5770 
 
5771 
  thrift_spec = (
5772 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5773 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5774 
  )
5775 
 
5776 
  def __init__(self, success=None, isex=None,):
5777 
    self.success = success
5778 
    self.isex = isex
5779 
 
5780 
  def read(self, iprot):
5781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5783 
      return
5784 
    iprot.readStructBegin()
5785 
    while True:
5786 
      (fname, ftype, fid) = iprot.readFieldBegin()
5787 
      if ftype == TType.STOP:
5788 
        break
5789 
      if fid == 0:
5790 
        if ftype == TType.STRUCT:
5791 
          self.success = ItemShippingInfo()
5792 
          self.success.read(iprot)
5793 
        else:
5794 
          iprot.skip(ftype)
5795 
      elif fid == 1:
5796 
        if ftype == TType.STRUCT:
5797 
          self.isex = CatalogServiceException()
5798 
          self.isex.read(iprot)
5799 
        else:
5800 
          iprot.skip(ftype)
5801 
      else:
5802 
        iprot.skip(ftype)
5803 
      iprot.readFieldEnd()
5804 
    iprot.readStructEnd()
5805 
 
5806 
  def write(self, oprot):
5807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5809 
      return
5810 
    oprot.writeStructBegin('isActive_result')
5811 
    if self.success is not None:
5812 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5813 
      self.success.write(oprot)
5814 
      oprot.writeFieldEnd()
5815 
    if self.isex is not None:
5816 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5817 
      self.isex.write(oprot)
5818 
      oprot.writeFieldEnd()
5819 
    oprot.writeFieldStop()
5820 
    oprot.writeStructEnd()
5821 
 
5822 
  def validate(self):
5823 
    return
5824 
 
5825 
 
5826 
  def __repr__(self):
5827 
    L = ['%s=%r' % (key, value)
5828 
      for key, value in self.__dict__.iteritems()]
5829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5830 
 
5831 
  def __eq__(self, other):
5832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5833 
 
5834 
  def __ne__(self, other):
5835 
    return not (self == other)
5836 
 
7438 amit.gupta 5837 
class getItemsStatus_args:
5838 
  """
5839 
  Attributes:
5840 
   - itemIds
5841 
  """
5842 
 
5843 
  thrift_spec = (
5844 
    None, # 0
5845 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5846 
  )
5847 
 
5848 
  def __init__(self, itemIds=None,):
5849 
    self.itemIds = itemIds
5850 
 
5851 
  def read(self, iprot):
5852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5854 
      return
5855 
    iprot.readStructBegin()
5856 
    while True:
5857 
      (fname, ftype, fid) = iprot.readFieldBegin()
5858 
      if ftype == TType.STOP:
5859 
        break
5860 
      if fid == 1:
5861 
        if ftype == TType.LIST:
5862 
          self.itemIds = []
5863 
          (_etype19, _size16) = iprot.readListBegin()
5864 
          for _i20 in xrange(_size16):
5865 
            _elem21 = iprot.readI64();
5866 
            self.itemIds.append(_elem21)
5867 
          iprot.readListEnd()
5868 
        else:
5869 
          iprot.skip(ftype)
5870 
      else:
5871 
        iprot.skip(ftype)
5872 
      iprot.readFieldEnd()
5873 
    iprot.readStructEnd()
5874 
 
5875 
  def write(self, oprot):
5876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5878 
      return
5879 
    oprot.writeStructBegin('getItemsStatus_args')
5880 
    if self.itemIds is not None:
5881 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5882 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5883 
      for iter22 in self.itemIds:
5884 
        oprot.writeI64(iter22)
5885 
      oprot.writeListEnd()
5886 
      oprot.writeFieldEnd()
5887 
    oprot.writeFieldStop()
5888 
    oprot.writeStructEnd()
5889 
 
5890 
  def validate(self):
5891 
    return
5892 
 
5893 
 
5894 
  def __repr__(self):
5895 
    L = ['%s=%r' % (key, value)
5896 
      for key, value in self.__dict__.iteritems()]
5897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5898 
 
5899 
  def __eq__(self, other):
5900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5901 
 
5902 
  def __ne__(self, other):
5903 
    return not (self == other)
5904 
 
5905 
class getItemsStatus_result:
5906 
  """
5907 
  Attributes:
5908 
   - success
5909 
   - isex
5910 
  """
5911 
 
5912 
  thrift_spec = (
5913 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5914 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5915 
  )
5916 
 
5917 
  def __init__(self, success=None, isex=None,):
5918 
    self.success = success
5919 
    self.isex = isex
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 == 0:
5931 
        if ftype == TType.MAP:
5932 
          self.success = {}
5933 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5934 
          for _i27 in xrange(_size23):
5935 
            _key28 = iprot.readI64();
5936 
            _val29 = iprot.readBool();
5937 
            self.success[_key28] = _val29
5938 
          iprot.readMapEnd()
5939 
        else:
5940 
          iprot.skip(ftype)
5941 
      elif fid == 1:
5942 
        if ftype == TType.STRUCT:
5943 
          self.isex = CatalogServiceException()
5944 
          self.isex.read(iprot)
5945 
        else:
5946 
          iprot.skip(ftype)
5947 
      else:
5948 
        iprot.skip(ftype)
5949 
      iprot.readFieldEnd()
5950 
    iprot.readStructEnd()
5951 
 
5952 
  def write(self, oprot):
5953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5955 
      return
5956 
    oprot.writeStructBegin('getItemsStatus_result')
5957 
    if self.success is not None:
5958 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5959 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5960 
      for kiter30,viter31 in self.success.items():
5961 
        oprot.writeI64(kiter30)
5962 
        oprot.writeBool(viter31)
5963 
      oprot.writeMapEnd()
5964 
      oprot.writeFieldEnd()
5965 
    if self.isex is not None:
5966 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5967 
      self.isex.write(oprot)
5968 
      oprot.writeFieldEnd()
5969 
    oprot.writeFieldStop()
5970 
    oprot.writeStructEnd()
5971 
 
5972 
  def validate(self):
5973 
    return
5974 
 
5975 
 
5976 
  def __repr__(self):
5977 
    L = ['%s=%r' % (key, value)
5978 
      for key, value in self.__dict__.iteritems()]
5979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5980 
 
5981 
  def __eq__(self, other):
5982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5983 
 
5984 
  def __ne__(self, other):
5985 
    return not (self == other)
5986 
 
5944 mandeep.dh 5987 
class getItemStatusDescription_args:
5988 
  """
5989 
  Attributes:
5990 
   - itemId
5991 
  """
5992 
 
5993 
  thrift_spec = (
5994 
    None, # 0
5995 
    (1, TType.I64, 'itemId', None, None, ), # 1
5996 
  )
5997 
 
5998 
  def __init__(self, itemId=None,):
5999 
    self.itemId = itemId
6000 
 
6001 
  def read(self, iprot):
6002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6004 
      return
6005 
    iprot.readStructBegin()
6006 
    while True:
6007 
      (fname, ftype, fid) = iprot.readFieldBegin()
6008 
      if ftype == TType.STOP:
6009 
        break
6010 
      if fid == 1:
6011 
        if ftype == TType.I64:
6012 
          self.itemId = iprot.readI64();
6013 
        else:
6014 
          iprot.skip(ftype)
6015 
      else:
6016 
        iprot.skip(ftype)
6017 
      iprot.readFieldEnd()
6018 
    iprot.readStructEnd()
6019 
 
6020 
  def write(self, oprot):
6021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6023 
      return
6024 
    oprot.writeStructBegin('getItemStatusDescription_args')
6025 
    if self.itemId is not None:
6026 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6027 
      oprot.writeI64(self.itemId)
6028 
      oprot.writeFieldEnd()
6029 
    oprot.writeFieldStop()
6030 
    oprot.writeStructEnd()
6031 
 
6032 
  def validate(self):
6033 
    return
6034 
 
6035 
 
6036 
  def __repr__(self):
6037 
    L = ['%s=%r' % (key, value)
6038 
      for key, value in self.__dict__.iteritems()]
6039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6040 
 
6041 
  def __eq__(self, other):
6042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6043 
 
6044 
  def __ne__(self, other):
6045 
    return not (self == other)
6046 
 
6047 
class getItemStatusDescription_result:
6048 
  """
6049 
  Attributes:
6050 
   - success
6051 
   - isex
6052 
  """
6053 
 
6054 
  thrift_spec = (
6055 
    (0, TType.STRING, 'success', None, None, ), # 0
6056 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6057 
  )
6058 
 
6059 
  def __init__(self, success=None, isex=None,):
6060 
    self.success = success
6061 
    self.isex = isex
6062 
 
6063 
  def read(self, iprot):
6064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6066 
      return
6067 
    iprot.readStructBegin()
6068 
    while True:
6069 
      (fname, ftype, fid) = iprot.readFieldBegin()
6070 
      if ftype == TType.STOP:
6071 
        break
6072 
      if fid == 0:
6073 
        if ftype == TType.STRING:
6074 
          self.success = iprot.readString();
6075 
        else:
6076 
          iprot.skip(ftype)
6077 
      elif fid == 1:
6078 
        if ftype == TType.STRUCT:
6079 
          self.isex = CatalogServiceException()
6080 
          self.isex.read(iprot)
6081 
        else:
6082 
          iprot.skip(ftype)
6083 
      else:
6084 
        iprot.skip(ftype)
6085 
      iprot.readFieldEnd()
6086 
    iprot.readStructEnd()
6087 
 
6088 
  def write(self, oprot):
6089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6091 
      return
6092 
    oprot.writeStructBegin('getItemStatusDescription_result')
6093 
    if self.success is not None:
6094 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6095 
      oprot.writeString(self.success)
6096 
      oprot.writeFieldEnd()
6097 
    if self.isex is not None:
6098 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6099 
      self.isex.write(oprot)
6100 
      oprot.writeFieldEnd()
6101 
    oprot.writeFieldStop()
6102 
    oprot.writeStructEnd()
6103 
 
6104 
  def validate(self):
6105 
    return
6106 
 
6107 
 
6108 
  def __repr__(self):
6109 
    L = ['%s=%r' % (key, value)
6110 
      for key, value in self.__dict__.iteritems()]
6111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6112 
 
6113 
  def __eq__(self, other):
6114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6115 
 
6116 
  def __ne__(self, other):
6117 
    return not (self == other)
6118 
 
6119 
class startItemOn_args:
6120 
  """
6121 
  Attributes:
6122 
   - item_id
6123 
   - timestamp
6124 
  """
6125 
 
6126 
  thrift_spec = (
6127 
    None, # 0
6128 
    (1, TType.I64, 'item_id', None, None, ), # 1
6129 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6130 
  )
6131 
 
6132 
  def __init__(self, item_id=None, timestamp=None,):
6133 
    self.item_id = item_id
6134 
    self.timestamp = timestamp
6135 
 
6136 
  def read(self, iprot):
6137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6139 
      return
6140 
    iprot.readStructBegin()
6141 
    while True:
6142 
      (fname, ftype, fid) = iprot.readFieldBegin()
6143 
      if ftype == TType.STOP:
6144 
        break
6145 
      if fid == 1:
6146 
        if ftype == TType.I64:
6147 
          self.item_id = iprot.readI64();
6148 
        else:
6149 
          iprot.skip(ftype)
6150 
      elif fid == 2:
6151 
        if ftype == TType.I64:
6152 
          self.timestamp = iprot.readI64();
6153 
        else:
6154 
          iprot.skip(ftype)
6155 
      else:
6156 
        iprot.skip(ftype)
6157 
      iprot.readFieldEnd()
6158 
    iprot.readStructEnd()
6159 
 
6160 
  def write(self, oprot):
6161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6163 
      return
6164 
    oprot.writeStructBegin('startItemOn_args')
6165 
    if self.item_id is not None:
6166 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6167 
      oprot.writeI64(self.item_id)
6168 
      oprot.writeFieldEnd()
6169 
    if self.timestamp is not None:
6170 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6171 
      oprot.writeI64(self.timestamp)
6172 
      oprot.writeFieldEnd()
6173 
    oprot.writeFieldStop()
6174 
    oprot.writeStructEnd()
6175 
 
6176 
  def validate(self):
6177 
    return
6178 
 
6179 
 
6180 
  def __repr__(self):
6181 
    L = ['%s=%r' % (key, value)
6182 
      for key, value in self.__dict__.iteritems()]
6183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6184 
 
6185 
  def __eq__(self, other):
6186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6187 
 
6188 
  def __ne__(self, other):
6189 
    return not (self == other)
6190 
 
6191 
class startItemOn_result:
6192 
  """
6193 
  Attributes:
6194 
   - cex
6195 
  """
6196 
 
6197 
  thrift_spec = (
6198 
    None, # 0
6199 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6200 
  )
6201 
 
6202 
  def __init__(self, cex=None,):
6203 
    self.cex = cex
6204 
 
6205 
  def read(self, iprot):
6206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6208 
      return
6209 
    iprot.readStructBegin()
6210 
    while True:
6211 
      (fname, ftype, fid) = iprot.readFieldBegin()
6212 
      if ftype == TType.STOP:
6213 
        break
6214 
      if fid == 1:
6215 
        if ftype == TType.STRUCT:
6216 
          self.cex = CatalogServiceException()
6217 
          self.cex.read(iprot)
6218 
        else:
6219 
          iprot.skip(ftype)
6220 
      else:
6221 
        iprot.skip(ftype)
6222 
      iprot.readFieldEnd()
6223 
    iprot.readStructEnd()
6224 
 
6225 
  def write(self, oprot):
6226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6228 
      return
6229 
    oprot.writeStructBegin('startItemOn_result')
6230 
    if self.cex is not None:
6231 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6232 
      self.cex.write(oprot)
6233 
      oprot.writeFieldEnd()
6234 
    oprot.writeFieldStop()
6235 
    oprot.writeStructEnd()
6236 
 
6237 
  def validate(self):
6238 
    return
6239 
 
6240 
 
6241 
  def __repr__(self):
6242 
    L = ['%s=%r' % (key, value)
6243 
      for key, value in self.__dict__.iteritems()]
6244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6245 
 
6246 
  def __eq__(self, other):
6247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6248 
 
6249 
  def __ne__(self, other):
6250 
    return not (self == other)
6251 
 
6252 
class retireItemOn_args:
6253 
  """
6254 
  Attributes:
6255 
   - item_id
6256 
   - timestamp
6257 
  """
6258 
 
6259 
  thrift_spec = (
6260 
    None, # 0
6261 
    (1, TType.I64, 'item_id', None, None, ), # 1
6262 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6263 
  )
6264 
 
6265 
  def __init__(self, item_id=None, timestamp=None,):
6266 
    self.item_id = item_id
6267 
    self.timestamp = timestamp
6268 
 
6269 
  def read(self, iprot):
6270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6272 
      return
6273 
    iprot.readStructBegin()
6274 
    while True:
6275 
      (fname, ftype, fid) = iprot.readFieldBegin()
6276 
      if ftype == TType.STOP:
6277 
        break
6278 
      if fid == 1:
6279 
        if ftype == TType.I64:
6280 
          self.item_id = iprot.readI64();
6281 
        else:
6282 
          iprot.skip(ftype)
6283 
      elif fid == 2:
6284 
        if ftype == TType.I64:
6285 
          self.timestamp = iprot.readI64();
6286 
        else:
6287 
          iprot.skip(ftype)
6288 
      else:
6289 
        iprot.skip(ftype)
6290 
      iprot.readFieldEnd()
6291 
    iprot.readStructEnd()
6292 
 
6293 
  def write(self, oprot):
6294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6296 
      return
6297 
    oprot.writeStructBegin('retireItemOn_args')
6298 
    if self.item_id is not None:
6299 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6300 
      oprot.writeI64(self.item_id)
6301 
      oprot.writeFieldEnd()
6302 
    if self.timestamp is not None:
6303 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6304 
      oprot.writeI64(self.timestamp)
6305 
      oprot.writeFieldEnd()
6306 
    oprot.writeFieldStop()
6307 
    oprot.writeStructEnd()
6308 
 
6309 
  def validate(self):
6310 
    return
6311 
 
6312 
 
6313 
  def __repr__(self):
6314 
    L = ['%s=%r' % (key, value)
6315 
      for key, value in self.__dict__.iteritems()]
6316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6317 
 
6318 
  def __eq__(self, other):
6319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6320 
 
6321 
  def __ne__(self, other):
6322 
    return not (self == other)
6323 
 
6324 
class retireItemOn_result:
6325 
  """
6326 
  Attributes:
6327 
   - cex
6328 
  """
6329 
 
6330 
  thrift_spec = (
6331 
    None, # 0
6332 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6333 
  )
6334 
 
6335 
  def __init__(self, cex=None,):
6336 
    self.cex = cex
6337 
 
6338 
  def read(self, iprot):
6339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6341 
      return
6342 
    iprot.readStructBegin()
6343 
    while True:
6344 
      (fname, ftype, fid) = iprot.readFieldBegin()
6345 
      if ftype == TType.STOP:
6346 
        break
6347 
      if fid == 1:
6348 
        if ftype == TType.STRUCT:
6349 
          self.cex = CatalogServiceException()
6350 
          self.cex.read(iprot)
6351 
        else:
6352 
          iprot.skip(ftype)
6353 
      else:
6354 
        iprot.skip(ftype)
6355 
      iprot.readFieldEnd()
6356 
    iprot.readStructEnd()
6357 
 
6358 
  def write(self, oprot):
6359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6361 
      return
6362 
    oprot.writeStructBegin('retireItemOn_result')
6363 
    if self.cex is not None:
6364 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6365 
      self.cex.write(oprot)
6366 
      oprot.writeFieldEnd()
6367 
    oprot.writeFieldStop()
6368 
    oprot.writeStructEnd()
6369 
 
6370 
  def validate(self):
6371 
    return
6372 
 
6373 
 
6374 
  def __repr__(self):
6375 
    L = ['%s=%r' % (key, value)
6376 
      for key, value in self.__dict__.iteritems()]
6377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6378 
 
6379 
  def __eq__(self, other):
6380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6381 
 
6382 
  def __ne__(self, other):
6383 
    return not (self == other)
6384 
 
6385 
class changeItemStatus_args:
6386 
  """
6387 
  Attributes:
6388 
   - item_id
6389 
   - timestamp
6390 
   - newstatus
6391 
  """
6392 
 
6393 
  thrift_spec = (
6394 
    None, # 0
6395 
    (1, TType.I64, 'item_id', None, None, ), # 1
6396 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6397 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6398 
  )
6399 
 
6400 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6401 
    self.item_id = item_id
6402 
    self.timestamp = timestamp
6403 
    self.newstatus = newstatus
6404 
 
6405 
  def read(self, iprot):
6406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6408 
      return
6409 
    iprot.readStructBegin()
6410 
    while True:
6411 
      (fname, ftype, fid) = iprot.readFieldBegin()
6412 
      if ftype == TType.STOP:
6413 
        break
6414 
      if fid == 1:
6415 
        if ftype == TType.I64:
6416 
          self.item_id = iprot.readI64();
6417 
        else:
6418 
          iprot.skip(ftype)
6419 
      elif fid == 2:
6420 
        if ftype == TType.I64:
6421 
          self.timestamp = iprot.readI64();
6422 
        else:
6423 
          iprot.skip(ftype)
6424 
      elif fid == 3:
6425 
        if ftype == TType.I32:
6426 
          self.newstatus = iprot.readI32();
6427 
        else:
6428 
          iprot.skip(ftype)
6429 
      else:
6430 
        iprot.skip(ftype)
6431 
      iprot.readFieldEnd()
6432 
    iprot.readStructEnd()
6433 
 
6434 
  def write(self, oprot):
6435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6437 
      return
6438 
    oprot.writeStructBegin('changeItemStatus_args')
6439 
    if self.item_id is not None:
6440 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6441 
      oprot.writeI64(self.item_id)
6442 
      oprot.writeFieldEnd()
6443 
    if self.timestamp is not None:
6444 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6445 
      oprot.writeI64(self.timestamp)
6446 
      oprot.writeFieldEnd()
6447 
    if self.newstatus is not None:
6448 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6449 
      oprot.writeI32(self.newstatus)
6450 
      oprot.writeFieldEnd()
6451 
    oprot.writeFieldStop()
6452 
    oprot.writeStructEnd()
6453 
 
6454 
  def validate(self):
6455 
    return
6456 
 
6457 
 
6458 
  def __repr__(self):
6459 
    L = ['%s=%r' % (key, value)
6460 
      for key, value in self.__dict__.iteritems()]
6461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6462 
 
6463 
  def __eq__(self, other):
6464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6465 
 
6466 
  def __ne__(self, other):
6467 
    return not (self == other)
6468 
 
6469 
class changeItemStatus_result:
6470 
  """
6471 
  Attributes:
6472 
   - cex
6473 
  """
6474 
 
6475 
  thrift_spec = (
6476 
    None, # 0
6477 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6478 
  )
6479 
 
6480 
  def __init__(self, cex=None,):
6481 
    self.cex = cex
6482 
 
6483 
  def read(self, iprot):
6484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6486 
      return
6487 
    iprot.readStructBegin()
6488 
    while True:
6489 
      (fname, ftype, fid) = iprot.readFieldBegin()
6490 
      if ftype == TType.STOP:
6491 
        break
6492 
      if fid == 1:
6493 
        if ftype == TType.STRUCT:
6494 
          self.cex = CatalogServiceException()
6495 
          self.cex.read(iprot)
6496 
        else:
6497 
          iprot.skip(ftype)
6498 
      else:
6499 
        iprot.skip(ftype)
6500 
      iprot.readFieldEnd()
6501 
    iprot.readStructEnd()
6502 
 
6503 
  def write(self, oprot):
6504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6506 
      return
6507 
    oprot.writeStructBegin('changeItemStatus_result')
6508 
    if self.cex is not None:
6509 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6510 
      self.cex.write(oprot)
6511 
      oprot.writeFieldEnd()
6512 
    oprot.writeFieldStop()
6513 
    oprot.writeStructEnd()
6514 
 
6515 
  def validate(self):
6516 
    return
6517 
 
6518 
 
6519 
  def __repr__(self):
6520 
    L = ['%s=%r' % (key, value)
6521 
      for key, value in self.__dict__.iteritems()]
6522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6523 
 
6524 
  def __eq__(self, other):
6525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6526 
 
6527 
  def __ne__(self, other):
6528 
    return not (self == other)
6529 
 
6530 
class getItem_args:
6531 
  """
6532 
  Attributes:
6533 
   - item_id
6534 
  """
6535 
 
6536 
  thrift_spec = (
6537 
    None, # 0
6538 
    (1, TType.I64, 'item_id', None, None, ), # 1
6539 
  )
6540 
 
6541 
  def __init__(self, item_id=None,):
6542 
    self.item_id = item_id
6543 
 
6544 
  def read(self, iprot):
6545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6547 
      return
6548 
    iprot.readStructBegin()
6549 
    while True:
6550 
      (fname, ftype, fid) = iprot.readFieldBegin()
6551 
      if ftype == TType.STOP:
6552 
        break
6553 
      if fid == 1:
6554 
        if ftype == TType.I64:
6555 
          self.item_id = iprot.readI64();
6556 
        else:
6557 
          iprot.skip(ftype)
6558 
      else:
6559 
        iprot.skip(ftype)
6560 
      iprot.readFieldEnd()
6561 
    iprot.readStructEnd()
6562 
 
6563 
  def write(self, oprot):
6564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6566 
      return
6567 
    oprot.writeStructBegin('getItem_args')
6568 
    if self.item_id is not None:
6569 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6570 
      oprot.writeI64(self.item_id)
6571 
      oprot.writeFieldEnd()
6572 
    oprot.writeFieldStop()
6573 
    oprot.writeStructEnd()
6574 
 
6575 
  def validate(self):
6576 
    return
6577 
 
6578 
 
6579 
  def __repr__(self):
6580 
    L = ['%s=%r' % (key, value)
6581 
      for key, value in self.__dict__.iteritems()]
6582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6583 
 
6584 
  def __eq__(self, other):
6585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6586 
 
6587 
  def __ne__(self, other):
6588 
    return not (self == other)
6589 
 
6590 
class getItem_result:
6591 
  """
6592 
  Attributes:
6593 
   - success
6594 
   - cex
6595 
  """
6596 
 
6597 
  thrift_spec = (
6598 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6599 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6600 
  )
6601 
 
6602 
  def __init__(self, success=None, cex=None,):
6603 
    self.success = success
6604 
    self.cex = cex
6605 
 
6606 
  def read(self, iprot):
6607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6609 
      return
6610 
    iprot.readStructBegin()
6611 
    while True:
6612 
      (fname, ftype, fid) = iprot.readFieldBegin()
6613 
      if ftype == TType.STOP:
6614 
        break
6615 
      if fid == 0:
6616 
        if ftype == TType.STRUCT:
6617 
          self.success = Item()
6618 
          self.success.read(iprot)
6619 
        else:
6620 
          iprot.skip(ftype)
6621 
      elif fid == 1:
6622 
        if ftype == TType.STRUCT:
6623 
          self.cex = CatalogServiceException()
6624 
          self.cex.read(iprot)
6625 
        else:
6626 
          iprot.skip(ftype)
6627 
      else:
6628 
        iprot.skip(ftype)
6629 
      iprot.readFieldEnd()
6630 
    iprot.readStructEnd()
6631 
 
6632 
  def write(self, oprot):
6633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6635 
      return
6636 
    oprot.writeStructBegin('getItem_result')
6637 
    if self.success is not None:
6638 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6639 
      self.success.write(oprot)
6640 
      oprot.writeFieldEnd()
6641 
    if self.cex is not None:
6642 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6643 
      self.cex.write(oprot)
6644 
      oprot.writeFieldEnd()
6645 
    oprot.writeFieldStop()
6646 
    oprot.writeStructEnd()
6647 
 
6648 
  def validate(self):
6649 
    return
6650 
 
6651 
 
6652 
  def __repr__(self):
6653 
    L = ['%s=%r' % (key, value)
6654 
      for key, value in self.__dict__.iteritems()]
6655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6656 
 
6657 
  def __eq__(self, other):
6658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6659 
 
6660 
  def __ne__(self, other):
6661 
    return not (self == other)
6662 
 
6663 
class getItemsByCatalogId_args:
6664 
  """
6665 
  Attributes:
6666 
   - catalog_item_id
6667 
  """
6668 
 
6669 
  thrift_spec = (
6670 
    None, # 0
6671 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6672 
  )
6673 
 
6674 
  def __init__(self, catalog_item_id=None,):
6675 
    self.catalog_item_id = catalog_item_id
6676 
 
6677 
  def read(self, iprot):
6678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6680 
      return
6681 
    iprot.readStructBegin()
6682 
    while True:
6683 
      (fname, ftype, fid) = iprot.readFieldBegin()
6684 
      if ftype == TType.STOP:
6685 
        break
6686 
      if fid == 1:
6687 
        if ftype == TType.I64:
6688 
          self.catalog_item_id = iprot.readI64();
6689 
        else:
6690 
          iprot.skip(ftype)
6691 
      else:
6692 
        iprot.skip(ftype)
6693 
      iprot.readFieldEnd()
6694 
    iprot.readStructEnd()
6695 
 
6696 
  def write(self, oprot):
6697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6699 
      return
6700 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6701 
    if self.catalog_item_id is not None:
6702 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6703 
      oprot.writeI64(self.catalog_item_id)
6704 
      oprot.writeFieldEnd()
6705 
    oprot.writeFieldStop()
6706 
    oprot.writeStructEnd()
6707 
 
6708 
  def validate(self):
6709 
    return
6710 
 
6711 
 
6712 
  def __repr__(self):
6713 
    L = ['%s=%r' % (key, value)
6714 
      for key, value in self.__dict__.iteritems()]
6715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6716 
 
6717 
  def __eq__(self, other):
6718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6719 
 
6720 
  def __ne__(self, other):
6721 
    return not (self == other)
6722 
 
6723 
class getItemsByCatalogId_result:
6724 
  """
6725 
  Attributes:
6726 
   - success
6727 
   - cex
6728 
  """
6729 
 
6730 
  thrift_spec = (
6731 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6732 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6733 
  )
6734 
 
6735 
  def __init__(self, success=None, cex=None,):
6736 
    self.success = success
6737 
    self.cex = cex
6738 
 
6739 
  def read(self, iprot):
6740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6742 
      return
6743 
    iprot.readStructBegin()
6744 
    while True:
6745 
      (fname, ftype, fid) = iprot.readFieldBegin()
6746 
      if ftype == TType.STOP:
6747 
        break
6748 
      if fid == 0:
6749 
        if ftype == TType.LIST:
6750 
          self.success = []
7438 amit.gupta 6751 
          (_etype35, _size32) = iprot.readListBegin()
6752 
          for _i36 in xrange(_size32):
6753 
            _elem37 = Item()
6754 
            _elem37.read(iprot)
6755 
            self.success.append(_elem37)
5944 mandeep.dh 6756 
          iprot.readListEnd()
6757 
        else:
6758 
          iprot.skip(ftype)
6759 
      elif fid == 1:
6760 
        if ftype == TType.STRUCT:
6761 
          self.cex = CatalogServiceException()
6762 
          self.cex.read(iprot)
6763 
        else:
6764 
          iprot.skip(ftype)
6765 
      else:
6766 
        iprot.skip(ftype)
6767 
      iprot.readFieldEnd()
6768 
    iprot.readStructEnd()
6769 
 
6770 
  def write(self, oprot):
6771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6773 
      return
6774 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6775 
    if self.success is not None:
6776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6778 
      for iter38 in self.success:
6779 
        iter38.write(oprot)
5944 mandeep.dh 6780 
      oprot.writeListEnd()
6781 
      oprot.writeFieldEnd()
6782 
    if self.cex is not None:
6783 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6784 
      self.cex.write(oprot)
6785 
      oprot.writeFieldEnd()
6786 
    oprot.writeFieldStop()
6787 
    oprot.writeStructEnd()
6788 
 
6789 
  def validate(self):
6790 
    return
6791 
 
6792 
 
6793 
  def __repr__(self):
6794 
    L = ['%s=%r' % (key, value)
6795 
      for key, value in self.__dict__.iteritems()]
6796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6797 
 
6798 
  def __eq__(self, other):
6799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6800 
 
6801 
  def __ne__(self, other):
6802 
    return not (self == other)
6803 
 
6804 
class getValidItemsByCatalogId_args:
6805 
  """
6806 
  Attributes:
6807 
   - catalog_item_id
6808 
  """
6809 
 
6810 
  thrift_spec = (
6811 
    None, # 0
6812 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6813 
  )
6814 
 
6815 
  def __init__(self, catalog_item_id=None,):
6816 
    self.catalog_item_id = catalog_item_id
6817 
 
6818 
  def read(self, iprot):
6819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6821 
      return
6822 
    iprot.readStructBegin()
6823 
    while True:
6824 
      (fname, ftype, fid) = iprot.readFieldBegin()
6825 
      if ftype == TType.STOP:
6826 
        break
6827 
      if fid == 1:
6828 
        if ftype == TType.I64:
6829 
          self.catalog_item_id = iprot.readI64();
6830 
        else:
6831 
          iprot.skip(ftype)
6832 
      else:
6833 
        iprot.skip(ftype)
6834 
      iprot.readFieldEnd()
6835 
    iprot.readStructEnd()
6836 
 
6837 
  def write(self, oprot):
6838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6840 
      return
6841 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6842 
    if self.catalog_item_id is not None:
6843 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6844 
      oprot.writeI64(self.catalog_item_id)
6845 
      oprot.writeFieldEnd()
6846 
    oprot.writeFieldStop()
6847 
    oprot.writeStructEnd()
6848 
 
6849 
  def validate(self):
6850 
    return
6851 
 
6852 
 
6853 
  def __repr__(self):
6854 
    L = ['%s=%r' % (key, value)
6855 
      for key, value in self.__dict__.iteritems()]
6856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6857 
 
6858 
  def __eq__(self, other):
6859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6860 
 
6861 
  def __ne__(self, other):
6862 
    return not (self == other)
6863 
 
6864 
class getValidItemsByCatalogId_result:
6865 
  """
6866 
  Attributes:
6867 
   - success
6868 
   - cex
6869 
  """
6870 
 
6871 
  thrift_spec = (
6872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6873 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6874 
  )
6875 
 
6876 
  def __init__(self, success=None, cex=None,):
6877 
    self.success = success
6878 
    self.cex = cex
6879 
 
6880 
  def read(self, iprot):
6881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6883 
      return
6884 
    iprot.readStructBegin()
6885 
    while True:
6886 
      (fname, ftype, fid) = iprot.readFieldBegin()
6887 
      if ftype == TType.STOP:
6888 
        break
6889 
      if fid == 0:
6890 
        if ftype == TType.LIST:
6891 
          self.success = []
7438 amit.gupta 6892 
          (_etype42, _size39) = iprot.readListBegin()
6893 
          for _i43 in xrange(_size39):
6894 
            _elem44 = Item()
6895 
            _elem44.read(iprot)
6896 
            self.success.append(_elem44)
5944 mandeep.dh 6897 
          iprot.readListEnd()
6898 
        else:
6899 
          iprot.skip(ftype)
6900 
      elif fid == 1:
6901 
        if ftype == TType.STRUCT:
6902 
          self.cex = CatalogServiceException()
6903 
          self.cex.read(iprot)
6904 
        else:
6905 
          iprot.skip(ftype)
6906 
      else:
6907 
        iprot.skip(ftype)
6908 
      iprot.readFieldEnd()
6909 
    iprot.readStructEnd()
6910 
 
6911 
  def write(self, oprot):
6912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6914 
      return
6915 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6916 
    if self.success is not None:
6917 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6918 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6919 
      for iter45 in self.success:
6920 
        iter45.write(oprot)
5944 mandeep.dh 6921 
      oprot.writeListEnd()
6922 
      oprot.writeFieldEnd()
6923 
    if self.cex is not None:
6924 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6925 
      self.cex.write(oprot)
6926 
      oprot.writeFieldEnd()
6927 
    oprot.writeFieldStop()
6928 
    oprot.writeStructEnd()
6929 
 
6930 
  def validate(self):
6931 
    return
6932 
 
6933 
 
6934 
  def __repr__(self):
6935 
    L = ['%s=%r' % (key, value)
6936 
      for key, value in self.__dict__.iteritems()]
6937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6938 
 
6939 
  def __eq__(self, other):
6940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6941 
 
6942 
  def __ne__(self, other):
6943 
    return not (self == other)
6944 
 
6945 
class getAllItems_args:
6946 
  """
6947 
  Attributes:
6948 
   - isActive
6949 
  """
6950 
 
6951 
  thrift_spec = (
6952 
    None, # 0
6953 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6954 
  )
6955 
 
6956 
  def __init__(self, isActive=None,):
6957 
    self.isActive = isActive
6958 
 
6959 
  def read(self, iprot):
6960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6962 
      return
6963 
    iprot.readStructBegin()
6964 
    while True:
6965 
      (fname, ftype, fid) = iprot.readFieldBegin()
6966 
      if ftype == TType.STOP:
6967 
        break
6968 
      if fid == 1:
6969 
        if ftype == TType.BOOL:
6970 
          self.isActive = iprot.readBool();
6971 
        else:
6972 
          iprot.skip(ftype)
6973 
      else:
6974 
        iprot.skip(ftype)
6975 
      iprot.readFieldEnd()
6976 
    iprot.readStructEnd()
6977 
 
6978 
  def write(self, oprot):
6979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6981 
      return
6982 
    oprot.writeStructBegin('getAllItems_args')
6983 
    if self.isActive is not None:
6984 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6985 
      oprot.writeBool(self.isActive)
6986 
      oprot.writeFieldEnd()
6987 
    oprot.writeFieldStop()
6988 
    oprot.writeStructEnd()
6989 
 
6990 
  def validate(self):
6991 
    return
6992 
 
6993 
 
6994 
  def __repr__(self):
6995 
    L = ['%s=%r' % (key, value)
6996 
      for key, value in self.__dict__.iteritems()]
6997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6998 
 
6999 
  def __eq__(self, other):
7000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7001 
 
7002 
  def __ne__(self, other):
7003 
    return not (self == other)
7004 
 
7005 
class getAllItems_result:
7006 
  """
7007 
  Attributes:
7008 
   - success
7009 
   - cex
7010 
  """
7011 
 
7012 
  thrift_spec = (
7013 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7014 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7015 
  )
7016 
 
7017 
  def __init__(self, success=None, cex=None,):
7018 
    self.success = success
7019 
    self.cex = cex
7020 
 
7021 
  def read(self, iprot):
7022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7024 
      return
7025 
    iprot.readStructBegin()
7026 
    while True:
7027 
      (fname, ftype, fid) = iprot.readFieldBegin()
7028 
      if ftype == TType.STOP:
7029 
        break
7030 
      if fid == 0:
7031 
        if ftype == TType.LIST:
7032 
          self.success = []
7438 amit.gupta 7033 
          (_etype49, _size46) = iprot.readListBegin()
7034 
          for _i50 in xrange(_size46):
7035 
            _elem51 = Item()
7036 
            _elem51.read(iprot)
7037 
            self.success.append(_elem51)
5944 mandeep.dh 7038 
          iprot.readListEnd()
7039 
        else:
7040 
          iprot.skip(ftype)
7041 
      elif fid == 1:
7042 
        if ftype == TType.STRUCT:
7043 
          self.cex = CatalogServiceException()
7044 
          self.cex.read(iprot)
7045 
        else:
7046 
          iprot.skip(ftype)
7047 
      else:
7048 
        iprot.skip(ftype)
7049 
      iprot.readFieldEnd()
7050 
    iprot.readStructEnd()
7051 
 
7052 
  def write(self, oprot):
7053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7055 
      return
7056 
    oprot.writeStructBegin('getAllItems_result')
7057 
    if self.success is not None:
7058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7060 
      for iter52 in self.success:
7061 
        iter52.write(oprot)
5944 mandeep.dh 7062 
      oprot.writeListEnd()
7063 
      oprot.writeFieldEnd()
7064 
    if self.cex is not None:
7065 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7066 
      self.cex.write(oprot)
7067 
      oprot.writeFieldEnd()
7068 
    oprot.writeFieldStop()
7069 
    oprot.writeStructEnd()
7070 
 
7071 
  def validate(self):
7072 
    return
7073 
 
7074 
 
7075 
  def __repr__(self):
7076 
    L = ['%s=%r' % (key, value)
7077 
      for key, value in self.__dict__.iteritems()]
7078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7079 
 
7080 
  def __eq__(self, other):
7081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7082 
 
7083 
  def __ne__(self, other):
7084 
    return not (self == other)
7085 
 
7086 
class getAllItemsByStatus_args:
7087 
  """
7088 
  Attributes:
7089 
   - itemStatus
7090 
  """
7091 
 
7092 
  thrift_spec = (
7093 
    None, # 0
7094 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7095 
  )
7096 
 
7097 
  def __init__(self, itemStatus=None,):
7098 
    self.itemStatus = itemStatus
7099 
 
7100 
  def read(self, iprot):
7101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7103 
      return
7104 
    iprot.readStructBegin()
7105 
    while True:
7106 
      (fname, ftype, fid) = iprot.readFieldBegin()
7107 
      if ftype == TType.STOP:
7108 
        break
7109 
      if fid == 1:
7110 
        if ftype == TType.I32:
7111 
          self.itemStatus = iprot.readI32();
7112 
        else:
7113 
          iprot.skip(ftype)
7114 
      else:
7115 
        iprot.skip(ftype)
7116 
      iprot.readFieldEnd()
7117 
    iprot.readStructEnd()
7118 
 
7119 
  def write(self, oprot):
7120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7122 
      return
7123 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7124 
    if self.itemStatus is not None:
7125 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7126 
      oprot.writeI32(self.itemStatus)
7127 
      oprot.writeFieldEnd()
7128 
    oprot.writeFieldStop()
7129 
    oprot.writeStructEnd()
7130 
 
7131 
  def validate(self):
7132 
    return
7133 
 
7134 
 
7135 
  def __repr__(self):
7136 
    L = ['%s=%r' % (key, value)
7137 
      for key, value in self.__dict__.iteritems()]
7138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7139 
 
7140 
  def __eq__(self, other):
7141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7142 
 
7143 
  def __ne__(self, other):
7144 
    return not (self == other)
7145 
 
7146 
class getAllItemsByStatus_result:
7147 
  """
7148 
  Attributes:
7149 
   - success
7150 
   - cex
7151 
  """
7152 
 
7153 
  thrift_spec = (
7154 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7155 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7156 
  )
7157 
 
7158 
  def __init__(self, success=None, cex=None,):
7159 
    self.success = success
7160 
    self.cex = cex
7161 
 
7162 
  def read(self, iprot):
7163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7165 
      return
7166 
    iprot.readStructBegin()
7167 
    while True:
7168 
      (fname, ftype, fid) = iprot.readFieldBegin()
7169 
      if ftype == TType.STOP:
7170 
        break
7171 
      if fid == 0:
7172 
        if ftype == TType.LIST:
7173 
          self.success = []
7438 amit.gupta 7174 
          (_etype56, _size53) = iprot.readListBegin()
7175 
          for _i57 in xrange(_size53):
7176 
            _elem58 = Item()
7177 
            _elem58.read(iprot)
7178 
            self.success.append(_elem58)
5944 mandeep.dh 7179 
          iprot.readListEnd()
7180 
        else:
7181 
          iprot.skip(ftype)
7182 
      elif fid == 1:
7183 
        if ftype == TType.STRUCT:
7184 
          self.cex = CatalogServiceException()
7185 
          self.cex.read(iprot)
7186 
        else:
7187 
          iprot.skip(ftype)
7188 
      else:
7189 
        iprot.skip(ftype)
7190 
      iprot.readFieldEnd()
7191 
    iprot.readStructEnd()
7192 
 
7193 
  def write(self, oprot):
7194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7196 
      return
7197 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7198 
    if self.success is not None:
7199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7201 
      for iter59 in self.success:
7202 
        iter59.write(oprot)
5944 mandeep.dh 7203 
      oprot.writeListEnd()
7204 
      oprot.writeFieldEnd()
7205 
    if self.cex is not None:
7206 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7207 
      self.cex.write(oprot)
7208 
      oprot.writeFieldEnd()
7209 
    oprot.writeFieldStop()
7210 
    oprot.writeStructEnd()
7211 
 
7212 
  def validate(self):
7213 
    return
7214 
 
7215 
 
7216 
  def __repr__(self):
7217 
    L = ['%s=%r' % (key, value)
7218 
      for key, value in self.__dict__.iteritems()]
7219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7220 
 
7221 
  def __eq__(self, other):
7222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7223 
 
7224 
  def __ne__(self, other):
7225 
    return not (self == other)
7226 
 
7227 
class markItemAsContentComplete_args:
7228 
  """
7229 
  Attributes:
7230 
   - entityId
7231 
   - category
7232 
   - brand
7233 
   - modelName
7234 
   - modelNumber
7235 
  """
7236 
 
7237 
  thrift_spec = (
7238 
    None, # 0
7239 
    (1, TType.I64, 'entityId', None, None, ), # 1
7240 
    (2, TType.I64, 'category', None, None, ), # 2
7241 
    (3, TType.STRING, 'brand', None, None, ), # 3
7242 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7243 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7244 
  )
7245 
 
7246 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7247 
    self.entityId = entityId
7248 
    self.category = category
7249 
    self.brand = brand
7250 
    self.modelName = modelName
7251 
    self.modelNumber = modelNumber
7252 
 
7253 
  def read(self, iprot):
7254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7256 
      return
7257 
    iprot.readStructBegin()
7258 
    while True:
7259 
      (fname, ftype, fid) = iprot.readFieldBegin()
7260 
      if ftype == TType.STOP:
7261 
        break
7262 
      if fid == 1:
7263 
        if ftype == TType.I64:
7264 
          self.entityId = iprot.readI64();
7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 2:
7268 
        if ftype == TType.I64:
7269 
          self.category = iprot.readI64();
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      elif fid == 3:
7273 
        if ftype == TType.STRING:
7274 
          self.brand = iprot.readString();
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      elif fid == 4:
7278 
        if ftype == TType.STRING:
7279 
          self.modelName = iprot.readString();
7280 
        else:
7281 
          iprot.skip(ftype)
7282 
      elif fid == 5:
7283 
        if ftype == TType.STRING:
7284 
          self.modelNumber = iprot.readString();
7285 
        else:
7286 
          iprot.skip(ftype)
7287 
      else:
7288 
        iprot.skip(ftype)
7289 
      iprot.readFieldEnd()
7290 
    iprot.readStructEnd()
7291 
 
7292 
  def write(self, oprot):
7293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7295 
      return
7296 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7297 
    if self.entityId is not None:
7298 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7299 
      oprot.writeI64(self.entityId)
7300 
      oprot.writeFieldEnd()
7301 
    if self.category is not None:
7302 
      oprot.writeFieldBegin('category', TType.I64, 2)
7303 
      oprot.writeI64(self.category)
7304 
      oprot.writeFieldEnd()
7305 
    if self.brand is not None:
7306 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7307 
      oprot.writeString(self.brand)
7308 
      oprot.writeFieldEnd()
7309 
    if self.modelName is not None:
7310 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7311 
      oprot.writeString(self.modelName)
7312 
      oprot.writeFieldEnd()
7313 
    if self.modelNumber is not None:
7314 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7315 
      oprot.writeString(self.modelNumber)
7316 
      oprot.writeFieldEnd()
7317 
    oprot.writeFieldStop()
7318 
    oprot.writeStructEnd()
7319 
 
7320 
  def validate(self):
7321 
    return
7322 
 
7323 
 
7324 
  def __repr__(self):
7325 
    L = ['%s=%r' % (key, value)
7326 
      for key, value in self.__dict__.iteritems()]
7327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7328 
 
7329 
  def __eq__(self, other):
7330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7331 
 
7332 
  def __ne__(self, other):
7333 
    return not (self == other)
7334 
 
7335 
class markItemAsContentComplete_result:
7336 
  """
7337 
  Attributes:
7338 
   - success
7339 
   - cex
7340 
  """
7341 
 
7342 
  thrift_spec = (
7343 
    (0, TType.BOOL, 'success', None, None, ), # 0
7344 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7345 
  )
7346 
 
7347 
  def __init__(self, success=None, cex=None,):
7348 
    self.success = success
7349 
    self.cex = cex
7350 
 
7351 
  def read(self, iprot):
7352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7354 
      return
7355 
    iprot.readStructBegin()
7356 
    while True:
7357 
      (fname, ftype, fid) = iprot.readFieldBegin()
7358 
      if ftype == TType.STOP:
7359 
        break
7360 
      if fid == 0:
7361 
        if ftype == TType.BOOL:
7362 
          self.success = iprot.readBool();
7363 
        else:
7364 
          iprot.skip(ftype)
7365 
      elif fid == 1:
7366 
        if ftype == TType.STRUCT:
7367 
          self.cex = CatalogServiceException()
7368 
          self.cex.read(iprot)
7369 
        else:
7370 
          iprot.skip(ftype)
7371 
      else:
7372 
        iprot.skip(ftype)
7373 
      iprot.readFieldEnd()
7374 
    iprot.readStructEnd()
7375 
 
7376 
  def write(self, oprot):
7377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7379 
      return
7380 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7381 
    if self.success is not None:
7382 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7383 
      oprot.writeBool(self.success)
7384 
      oprot.writeFieldEnd()
7385 
    if self.cex is not None:
7386 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7387 
      self.cex.write(oprot)
7388 
      oprot.writeFieldEnd()
7389 
    oprot.writeFieldStop()
7390 
    oprot.writeStructEnd()
7391 
 
7392 
  def validate(self):
7393 
    return
7394 
 
7395 
 
7396 
  def __repr__(self):
7397 
    L = ['%s=%r' % (key, value)
7398 
      for key, value in self.__dict__.iteritems()]
7399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7400 
 
7401 
  def __eq__(self, other):
7402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7403 
 
7404 
  def __ne__(self, other):
7405 
    return not (self == other)
7406 
 
7407 
class getAllItemsInRange_args:
7408 
  """
7409 
  Attributes:
7410 
   - offset
7411 
   - limit
7412 
  """
7413 
 
7414 
  thrift_spec = (
7415 
    None, # 0
7416 
    (1, TType.I64, 'offset', None, None, ), # 1
7417 
    (2, TType.I64, 'limit', None, None, ), # 2
7418 
  )
7419 
 
7420 
  def __init__(self, offset=None, limit=None,):
7421 
    self.offset = offset
7422 
    self.limit = limit
7423 
 
7424 
  def read(self, iprot):
7425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7427 
      return
7428 
    iprot.readStructBegin()
7429 
    while True:
7430 
      (fname, ftype, fid) = iprot.readFieldBegin()
7431 
      if ftype == TType.STOP:
7432 
        break
7433 
      if fid == 1:
7434 
        if ftype == TType.I64:
7435 
          self.offset = iprot.readI64();
7436 
        else:
7437 
          iprot.skip(ftype)
7438 
      elif fid == 2:
7439 
        if ftype == TType.I64:
7440 
          self.limit = iprot.readI64();
7441 
        else:
7442 
          iprot.skip(ftype)
7443 
      else:
7444 
        iprot.skip(ftype)
7445 
      iprot.readFieldEnd()
7446 
    iprot.readStructEnd()
7447 
 
7448 
  def write(self, oprot):
7449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7451 
      return
7452 
    oprot.writeStructBegin('getAllItemsInRange_args')
7453 
    if self.offset is not None:
7454 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7455 
      oprot.writeI64(self.offset)
7456 
      oprot.writeFieldEnd()
7457 
    if self.limit is not None:
7458 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7459 
      oprot.writeI64(self.limit)
7460 
      oprot.writeFieldEnd()
7461 
    oprot.writeFieldStop()
7462 
    oprot.writeStructEnd()
7463 
 
7464 
  def validate(self):
7465 
    return
7466 
 
7467 
 
7468 
  def __repr__(self):
7469 
    L = ['%s=%r' % (key, value)
7470 
      for key, value in self.__dict__.iteritems()]
7471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7472 
 
7473 
  def __eq__(self, other):
7474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7475 
 
7476 
  def __ne__(self, other):
7477 
    return not (self == other)
7478 
 
7479 
class getAllItemsInRange_result:
7480 
  """
7481 
  Attributes:
7482 
   - success
7483 
   - cex
7484 
  """
7485 
 
7486 
  thrift_spec = (
7487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7488 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7489 
  )
7490 
 
7491 
  def __init__(self, success=None, cex=None,):
7492 
    self.success = success
7493 
    self.cex = cex
7494 
 
7495 
  def read(self, iprot):
7496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7498 
      return
7499 
    iprot.readStructBegin()
7500 
    while True:
7501 
      (fname, ftype, fid) = iprot.readFieldBegin()
7502 
      if ftype == TType.STOP:
7503 
        break
7504 
      if fid == 0:
7505 
        if ftype == TType.LIST:
7506 
          self.success = []
7438 amit.gupta 7507 
          (_etype63, _size60) = iprot.readListBegin()
7508 
          for _i64 in xrange(_size60):
7509 
            _elem65 = Item()
7510 
            _elem65.read(iprot)
7511 
            self.success.append(_elem65)
5944 mandeep.dh 7512 
          iprot.readListEnd()
7513 
        else:
7514 
          iprot.skip(ftype)
7515 
      elif fid == 1:
7516 
        if ftype == TType.STRUCT:
7517 
          self.cex = CatalogServiceException()
7518 
          self.cex.read(iprot)
7519 
        else:
7520 
          iprot.skip(ftype)
7521 
      else:
7522 
        iprot.skip(ftype)
7523 
      iprot.readFieldEnd()
7524 
    iprot.readStructEnd()
7525 
 
7526 
  def write(self, oprot):
7527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7529 
      return
7530 
    oprot.writeStructBegin('getAllItemsInRange_result')
7531 
    if self.success is not None:
7532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7533 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7534 
      for iter66 in self.success:
7535 
        iter66.write(oprot)
5944 mandeep.dh 7536 
      oprot.writeListEnd()
7537 
      oprot.writeFieldEnd()
7538 
    if self.cex is not None:
7539 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7540 
      self.cex.write(oprot)
7541 
      oprot.writeFieldEnd()
7542 
    oprot.writeFieldStop()
7543 
    oprot.writeStructEnd()
7544 
 
7545 
  def validate(self):
7546 
    return
7547 
 
7548 
 
7549 
  def __repr__(self):
7550 
    L = ['%s=%r' % (key, value)
7551 
      for key, value in self.__dict__.iteritems()]
7552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7553 
 
7554 
  def __eq__(self, other):
7555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7556 
 
7557 
  def __ne__(self, other):
7558 
    return not (self == other)
7559 
 
7560 
class getAllItemsByStatusInRange_args:
7561 
  """
7562 
  Attributes:
7563 
   - itemStatus
7564 
   - offset
7565 
   - limit
7566 
  """
7567 
 
7568 
  thrift_spec = (
7569 
    None, # 0
7570 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7571 
    (2, TType.I64, 'offset', None, None, ), # 2
7572 
    (3, TType.I64, 'limit', None, None, ), # 3
7573 
  )
7574 
 
7575 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7576 
    self.itemStatus = itemStatus
7577 
    self.offset = offset
7578 
    self.limit = limit
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 == 1:
7590 
        if ftype == TType.I32:
7591 
          self.itemStatus = iprot.readI32();
7592 
        else:
7593 
          iprot.skip(ftype)
7594 
      elif fid == 2:
7595 
        if ftype == TType.I64:
7596 
          self.offset = iprot.readI64();
7597 
        else:
7598 
          iprot.skip(ftype)
7599 
      elif fid == 3:
7600 
        if ftype == TType.I64:
7601 
          self.limit = iprot.readI64();
7602 
        else:
7603 
          iprot.skip(ftype)
7604 
      else:
7605 
        iprot.skip(ftype)
7606 
      iprot.readFieldEnd()
7607 
    iprot.readStructEnd()
7608 
 
7609 
  def write(self, oprot):
7610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7612 
      return
7613 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7614 
    if self.itemStatus is not None:
7615 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7616 
      oprot.writeI32(self.itemStatus)
7617 
      oprot.writeFieldEnd()
7618 
    if self.offset is not None:
7619 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7620 
      oprot.writeI64(self.offset)
7621 
      oprot.writeFieldEnd()
7622 
    if self.limit is not None:
7623 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7624 
      oprot.writeI64(self.limit)
7625 
      oprot.writeFieldEnd()
7626 
    oprot.writeFieldStop()
7627 
    oprot.writeStructEnd()
7628 
 
7629 
  def validate(self):
7630 
    return
7631 
 
7632 
 
7633 
  def __repr__(self):
7634 
    L = ['%s=%r' % (key, value)
7635 
      for key, value in self.__dict__.iteritems()]
7636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7637 
 
7638 
  def __eq__(self, other):
7639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7640 
 
7641 
  def __ne__(self, other):
7642 
    return not (self == other)
7643 
 
7644 
class getAllItemsByStatusInRange_result:
7645 
  """
7646 
  Attributes:
7647 
   - success
7648 
   - cex
7649 
  """
7650 
 
7651 
  thrift_spec = (
7652 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7653 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7654 
  )
7655 
 
7656 
  def __init__(self, success=None, cex=None,):
7657 
    self.success = success
7658 
    self.cex = cex
7659 
 
7660 
  def read(self, iprot):
7661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7663 
      return
7664 
    iprot.readStructBegin()
7665 
    while True:
7666 
      (fname, ftype, fid) = iprot.readFieldBegin()
7667 
      if ftype == TType.STOP:
7668 
        break
7669 
      if fid == 0:
7670 
        if ftype == TType.LIST:
7671 
          self.success = []
7438 amit.gupta 7672 
          (_etype70, _size67) = iprot.readListBegin()
7673 
          for _i71 in xrange(_size67):
7674 
            _elem72 = Item()
7675 
            _elem72.read(iprot)
7676 
            self.success.append(_elem72)
5944 mandeep.dh 7677 
          iprot.readListEnd()
7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      elif fid == 1:
7681 
        if ftype == TType.STRUCT:
7682 
          self.cex = CatalogServiceException()
7683 
          self.cex.read(iprot)
7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      else:
7687 
        iprot.skip(ftype)
7688 
      iprot.readFieldEnd()
7689 
    iprot.readStructEnd()
7690 
 
7691 
  def write(self, oprot):
7692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7694 
      return
7695 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7696 
    if self.success is not None:
7697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7699 
      for iter73 in self.success:
7700 
        iter73.write(oprot)
5944 mandeep.dh 7701 
      oprot.writeListEnd()
7702 
      oprot.writeFieldEnd()
7703 
    if self.cex is not None:
7704 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7705 
      self.cex.write(oprot)
7706 
      oprot.writeFieldEnd()
7707 
    oprot.writeFieldStop()
7708 
    oprot.writeStructEnd()
7709 
 
7710 
  def validate(self):
7711 
    return
7712 
 
7713 
 
7714 
  def __repr__(self):
7715 
    L = ['%s=%r' % (key, value)
7716 
      for key, value in self.__dict__.iteritems()]
7717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7718 
 
7719 
  def __eq__(self, other):
7720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7721 
 
7722 
  def __ne__(self, other):
7723 
    return not (self == other)
7724 
 
7725 
class getItemCountByStatus_args:
7726 
  """
7727 
  Attributes:
7728 
   - useStatus
7729 
   - itemStatus
7730 
  """
7731 
 
7732 
  thrift_spec = (
7733 
    None, # 0
7734 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7735 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7736 
  )
7737 
 
7738 
  def __init__(self, useStatus=None, itemStatus=None,):
7739 
    self.useStatus = useStatus
7740 
    self.itemStatus = itemStatus
7741 
 
7742 
  def read(self, iprot):
7743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7745 
      return
7746 
    iprot.readStructBegin()
7747 
    while True:
7748 
      (fname, ftype, fid) = iprot.readFieldBegin()
7749 
      if ftype == TType.STOP:
7750 
        break
7751 
      if fid == 1:
7752 
        if ftype == TType.BOOL:
7753 
          self.useStatus = iprot.readBool();
7754 
        else:
7755 
          iprot.skip(ftype)
7756 
      elif fid == 2:
7757 
        if ftype == TType.I32:
7758 
          self.itemStatus = iprot.readI32();
7759 
        else:
7760 
          iprot.skip(ftype)
7761 
      else:
7762 
        iprot.skip(ftype)
7763 
      iprot.readFieldEnd()
7764 
    iprot.readStructEnd()
7765 
 
7766 
  def write(self, oprot):
7767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7769 
      return
7770 
    oprot.writeStructBegin('getItemCountByStatus_args')
7771 
    if self.useStatus is not None:
7772 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7773 
      oprot.writeBool(self.useStatus)
7774 
      oprot.writeFieldEnd()
7775 
    if self.itemStatus is not None:
7776 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7777 
      oprot.writeI32(self.itemStatus)
7778 
      oprot.writeFieldEnd()
7779 
    oprot.writeFieldStop()
7780 
    oprot.writeStructEnd()
7781 
 
7782 
  def validate(self):
7783 
    return
7784 
 
7785 
 
7786 
  def __repr__(self):
7787 
    L = ['%s=%r' % (key, value)
7788 
      for key, value in self.__dict__.iteritems()]
7789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7790 
 
7791 
  def __eq__(self, other):
7792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7793 
 
7794 
  def __ne__(self, other):
7795 
    return not (self == other)
7796 
 
7797 
class getItemCountByStatus_result:
7798 
  """
7799 
  Attributes:
7800 
   - success
7801 
  """
7802 
 
7803 
  thrift_spec = (
7804 
    (0, TType.I32, 'success', None, None, ), # 0
7805 
  )
7806 
 
7807 
  def __init__(self, success=None,):
7808 
    self.success = success
7809 
 
7810 
  def read(self, iprot):
7811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7813 
      return
7814 
    iprot.readStructBegin()
7815 
    while True:
7816 
      (fname, ftype, fid) = iprot.readFieldBegin()
7817 
      if ftype == TType.STOP:
7818 
        break
7819 
      if fid == 0:
7820 
        if ftype == TType.I32:
7821 
          self.success = iprot.readI32();
7822 
        else:
7823 
          iprot.skip(ftype)
7824 
      else:
7825 
        iprot.skip(ftype)
7826 
      iprot.readFieldEnd()
7827 
    iprot.readStructEnd()
7828 
 
7829 
  def write(self, oprot):
7830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7832 
      return
7833 
    oprot.writeStructBegin('getItemCountByStatus_result')
7834 
    if self.success is not None:
7835 
      oprot.writeFieldBegin('success', TType.I32, 0)
7836 
      oprot.writeI32(self.success)
7837 
      oprot.writeFieldEnd()
7838 
    oprot.writeFieldStop()
7839 
    oprot.writeStructEnd()
7840 
 
7841 
  def validate(self):
7842 
    return
7843 
 
7844 
 
7845 
  def __repr__(self):
7846 
    L = ['%s=%r' % (key, value)
7847 
      for key, value in self.__dict__.iteritems()]
7848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7849 
 
7850 
  def __eq__(self, other):
7851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7852 
 
7853 
  def __ne__(self, other):
7854 
    return not (self == other)
7855 
 
7856 
class getBestSellers_args:
7857 
 
7858 
  thrift_spec = (
7859 
  )
7860 
 
7861 
  def read(self, iprot):
7862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7864 
      return
7865 
    iprot.readStructBegin()
7866 
    while True:
7867 
      (fname, ftype, fid) = iprot.readFieldBegin()
7868 
      if ftype == TType.STOP:
7869 
        break
7870 
      else:
7871 
        iprot.skip(ftype)
7872 
      iprot.readFieldEnd()
7873 
    iprot.readStructEnd()
7874 
 
7875 
  def write(self, oprot):
7876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7878 
      return
7879 
    oprot.writeStructBegin('getBestSellers_args')
7880 
    oprot.writeFieldStop()
7881 
    oprot.writeStructEnd()
7882 
 
7883 
  def validate(self):
7884 
    return
7885 
 
7886 
 
7887 
  def __repr__(self):
7888 
    L = ['%s=%r' % (key, value)
7889 
      for key, value in self.__dict__.iteritems()]
7890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7891 
 
7892 
  def __eq__(self, other):
7893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7894 
 
7895 
  def __ne__(self, other):
7896 
    return not (self == other)
7897 
 
7898 
class getBestSellers_result:
7899 
  """
7900 
  Attributes:
7901 
   - success
7902 
   - isex
7903 
  """
7904 
 
7905 
  thrift_spec = (
7906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7907 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7908 
  )
7909 
 
7910 
  def __init__(self, success=None, isex=None,):
7911 
    self.success = success
7912 
    self.isex = isex
7913 
 
7914 
  def read(self, iprot):
7915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7917 
      return
7918 
    iprot.readStructBegin()
7919 
    while True:
7920 
      (fname, ftype, fid) = iprot.readFieldBegin()
7921 
      if ftype == TType.STOP:
7922 
        break
7923 
      if fid == 0:
7924 
        if ftype == TType.LIST:
7925 
          self.success = []
7438 amit.gupta 7926 
          (_etype77, _size74) = iprot.readListBegin()
7927 
          for _i78 in xrange(_size74):
7928 
            _elem79 = Item()
7929 
            _elem79.read(iprot)
7930 
            self.success.append(_elem79)
5944 mandeep.dh 7931 
          iprot.readListEnd()
7932 
        else:
7933 
          iprot.skip(ftype)
7934 
      elif fid == 1:
7935 
        if ftype == TType.STRUCT:
7936 
          self.isex = CatalogServiceException()
7937 
          self.isex.read(iprot)
7938 
        else:
7939 
          iprot.skip(ftype)
7940 
      else:
7941 
        iprot.skip(ftype)
7942 
      iprot.readFieldEnd()
7943 
    iprot.readStructEnd()
7944 
 
7945 
  def write(self, oprot):
7946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7948 
      return
7949 
    oprot.writeStructBegin('getBestSellers_result')
7950 
    if self.success is not None:
7951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7953 
      for iter80 in self.success:
7954 
        iter80.write(oprot)
5944 mandeep.dh 7955 
      oprot.writeListEnd()
7956 
      oprot.writeFieldEnd()
7957 
    if self.isex is not None:
7958 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7959 
      self.isex.write(oprot)
7960 
      oprot.writeFieldEnd()
7961 
    oprot.writeFieldStop()
7962 
    oprot.writeStructEnd()
7963 
 
7964 
  def validate(self):
7965 
    return
7966 
 
7967 
 
7968 
  def __repr__(self):
7969 
    L = ['%s=%r' % (key, value)
7970 
      for key, value in self.__dict__.iteritems()]
7971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7972 
 
7973 
  def __eq__(self, other):
7974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7975 
 
7976 
  def __ne__(self, other):
7977 
    return not (self == other)
7978 
 
7979 
class getBestSellersCatalogIds_args:
7980 
  """
7981 
  Attributes:
7982 
   - beginIndex
7983 
   - totalItems
7984 
   - brand
7985 
   - category
7986 
  """
7987 
 
7988 
  thrift_spec = (
7989 
    None, # 0
7990 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7991 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7992 
    (3, TType.STRING, 'brand', None, None, ), # 3
7993 
    (4, TType.I64, 'category', None, None, ), # 4
7994 
  )
7995 
 
7996 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7997 
    self.beginIndex = beginIndex
7998 
    self.totalItems = totalItems
7999 
    self.brand = brand
8000 
    self.category = category
8001 
 
8002 
  def read(self, iprot):
8003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8005 
      return
8006 
    iprot.readStructBegin()
8007 
    while True:
8008 
      (fname, ftype, fid) = iprot.readFieldBegin()
8009 
      if ftype == TType.STOP:
8010 
        break
8011 
      if fid == 1:
8012 
        if ftype == TType.I64:
8013 
          self.beginIndex = iprot.readI64();
8014 
        else:
8015 
          iprot.skip(ftype)
8016 
      elif fid == 2:
8017 
        if ftype == TType.I64:
8018 
          self.totalItems = iprot.readI64();
8019 
        else:
8020 
          iprot.skip(ftype)
8021 
      elif fid == 3:
8022 
        if ftype == TType.STRING:
8023 
          self.brand = iprot.readString();
8024 
        else:
8025 
          iprot.skip(ftype)
8026 
      elif fid == 4:
8027 
        if ftype == TType.I64:
8028 
          self.category = iprot.readI64();
8029 
        else:
8030 
          iprot.skip(ftype)
8031 
      else:
8032 
        iprot.skip(ftype)
8033 
      iprot.readFieldEnd()
8034 
    iprot.readStructEnd()
8035 
 
8036 
  def write(self, oprot):
8037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8039 
      return
8040 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8041 
    if self.beginIndex is not None:
8042 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8043 
      oprot.writeI64(self.beginIndex)
8044 
      oprot.writeFieldEnd()
8045 
    if self.totalItems is not None:
8046 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8047 
      oprot.writeI64(self.totalItems)
8048 
      oprot.writeFieldEnd()
8049 
    if self.brand is not None:
8050 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8051 
      oprot.writeString(self.brand)
8052 
      oprot.writeFieldEnd()
8053 
    if self.category is not None:
8054 
      oprot.writeFieldBegin('category', TType.I64, 4)
8055 
      oprot.writeI64(self.category)
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 getBestSellersCatalogIds_result:
8076 
  """
8077 
  Attributes:
8078 
   - success
8079 
   - cex
8080 
  """
8081 
 
8082 
  thrift_spec = (
8083 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8084 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8085 
  )
8086 
 
8087 
  def __init__(self, success=None, cex=None,):
8088 
    self.success = success
8089 
    self.cex = cex
8090 
 
8091 
  def read(self, iprot):
8092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8094 
      return
8095 
    iprot.readStructBegin()
8096 
    while True:
8097 
      (fname, ftype, fid) = iprot.readFieldBegin()
8098 
      if ftype == TType.STOP:
8099 
        break
8100 
      if fid == 0:
8101 
        if ftype == TType.LIST:
8102 
          self.success = []
7438 amit.gupta 8103 
          (_etype84, _size81) = iprot.readListBegin()
8104 
          for _i85 in xrange(_size81):
8105 
            _elem86 = iprot.readI64();
8106 
            self.success.append(_elem86)
5944 mandeep.dh 8107 
          iprot.readListEnd()
8108 
        else:
8109 
          iprot.skip(ftype)
8110 
      elif fid == 1:
8111 
        if ftype == TType.STRUCT:
8112 
          self.cex = CatalogServiceException()
8113 
          self.cex.read(iprot)
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      else:
8117 
        iprot.skip(ftype)
8118 
      iprot.readFieldEnd()
8119 
    iprot.readStructEnd()
8120 
 
8121 
  def write(self, oprot):
8122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8124 
      return
8125 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8126 
    if self.success is not None:
8127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8128 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8129 
      for iter87 in self.success:
8130 
        oprot.writeI64(iter87)
5944 mandeep.dh 8131 
      oprot.writeListEnd()
8132 
      oprot.writeFieldEnd()
8133 
    if self.cex is not None:
8134 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8135 
      self.cex.write(oprot)
8136 
      oprot.writeFieldEnd()
8137 
    oprot.writeFieldStop()
8138 
    oprot.writeStructEnd()
8139 
 
8140 
  def validate(self):
8141 
    return
8142 
 
8143 
 
8144 
  def __repr__(self):
8145 
    L = ['%s=%r' % (key, value)
8146 
      for key, value in self.__dict__.iteritems()]
8147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8148 
 
8149 
  def __eq__(self, other):
8150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8151 
 
8152 
  def __ne__(self, other):
8153 
    return not (self == other)
8154 
 
8155 
class getBestSellersCount_args:
8156 
 
8157 
  thrift_spec = (
8158 
  )
8159 
 
8160 
  def read(self, iprot):
8161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8163 
      return
8164 
    iprot.readStructBegin()
8165 
    while True:
8166 
      (fname, ftype, fid) = iprot.readFieldBegin()
8167 
      if ftype == TType.STOP:
8168 
        break
8169 
      else:
8170 
        iprot.skip(ftype)
8171 
      iprot.readFieldEnd()
8172 
    iprot.readStructEnd()
8173 
 
8174 
  def write(self, oprot):
8175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8177 
      return
8178 
    oprot.writeStructBegin('getBestSellersCount_args')
8179 
    oprot.writeFieldStop()
8180 
    oprot.writeStructEnd()
8181 
 
8182 
  def validate(self):
8183 
    return
8184 
 
8185 
 
8186 
  def __repr__(self):
8187 
    L = ['%s=%r' % (key, value)
8188 
      for key, value in self.__dict__.iteritems()]
8189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8190 
 
8191 
  def __eq__(self, other):
8192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8193 
 
8194 
  def __ne__(self, other):
8195 
    return not (self == other)
8196 
 
8197 
class getBestSellersCount_result:
8198 
  """
8199 
  Attributes:
8200 
   - success
8201 
   - cex
8202 
  """
8203 
 
8204 
  thrift_spec = (
8205 
    (0, TType.I64, 'success', None, None, ), # 0
8206 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8207 
  )
8208 
 
8209 
  def __init__(self, success=None, cex=None,):
8210 
    self.success = success
8211 
    self.cex = cex
8212 
 
8213 
  def read(self, iprot):
8214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8216 
      return
8217 
    iprot.readStructBegin()
8218 
    while True:
8219 
      (fname, ftype, fid) = iprot.readFieldBegin()
8220 
      if ftype == TType.STOP:
8221 
        break
8222 
      if fid == 0:
8223 
        if ftype == TType.I64:
8224 
          self.success = iprot.readI64();
8225 
        else:
8226 
          iprot.skip(ftype)
8227 
      elif fid == 1:
8228 
        if ftype == TType.STRUCT:
8229 
          self.cex = CatalogServiceException()
8230 
          self.cex.read(iprot)
8231 
        else:
8232 
          iprot.skip(ftype)
8233 
      else:
8234 
        iprot.skip(ftype)
8235 
      iprot.readFieldEnd()
8236 
    iprot.readStructEnd()
8237 
 
8238 
  def write(self, oprot):
8239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8241 
      return
8242 
    oprot.writeStructBegin('getBestSellersCount_result')
8243 
    if self.success is not None:
8244 
      oprot.writeFieldBegin('success', TType.I64, 0)
8245 
      oprot.writeI64(self.success)
8246 
      oprot.writeFieldEnd()
8247 
    if self.cex is not None:
8248 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8249 
      self.cex.write(oprot)
8250 
      oprot.writeFieldEnd()
8251 
    oprot.writeFieldStop()
8252 
    oprot.writeStructEnd()
8253 
 
8254 
  def validate(self):
8255 
    return
8256 
 
8257 
 
8258 
  def __repr__(self):
8259 
    L = ['%s=%r' % (key, value)
8260 
      for key, value in self.__dict__.iteritems()]
8261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8262 
 
8263 
  def __eq__(self, other):
8264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8265 
 
8266 
  def __ne__(self, other):
8267 
    return not (self == other)
8268 
 
8269 
class getBestDeals_args:
8270 
 
8271 
  thrift_spec = (
8272 
  )
8273 
 
8274 
  def read(self, iprot):
8275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8277 
      return
8278 
    iprot.readStructBegin()
8279 
    while True:
8280 
      (fname, ftype, fid) = iprot.readFieldBegin()
8281 
      if ftype == TType.STOP:
8282 
        break
8283 
      else:
8284 
        iprot.skip(ftype)
8285 
      iprot.readFieldEnd()
8286 
    iprot.readStructEnd()
8287 
 
8288 
  def write(self, oprot):
8289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8291 
      return
8292 
    oprot.writeStructBegin('getBestDeals_args')
8293 
    oprot.writeFieldStop()
8294 
    oprot.writeStructEnd()
8295 
 
8296 
  def validate(self):
8297 
    return
8298 
 
8299 
 
8300 
  def __repr__(self):
8301 
    L = ['%s=%r' % (key, value)
8302 
      for key, value in self.__dict__.iteritems()]
8303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8304 
 
8305 
  def __eq__(self, other):
8306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8307 
 
8308 
  def __ne__(self, other):
8309 
    return not (self == other)
8310 
 
8311 
class getBestDeals_result:
8312 
  """
8313 
  Attributes:
8314 
   - success
8315 
   - isex
8316 
  """
8317 
 
8318 
  thrift_spec = (
8319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8320 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8321 
  )
8322 
 
8323 
  def __init__(self, success=None, isex=None,):
8324 
    self.success = success
8325 
    self.isex = isex
8326 
 
8327 
  def read(self, iprot):
8328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8330 
      return
8331 
    iprot.readStructBegin()
8332 
    while True:
8333 
      (fname, ftype, fid) = iprot.readFieldBegin()
8334 
      if ftype == TType.STOP:
8335 
        break
8336 
      if fid == 0:
8337 
        if ftype == TType.LIST:
8338 
          self.success = []
7438 amit.gupta 8339 
          (_etype91, _size88) = iprot.readListBegin()
8340 
          for _i92 in xrange(_size88):
8341 
            _elem93 = Item()
8342 
            _elem93.read(iprot)
8343 
            self.success.append(_elem93)
5944 mandeep.dh 8344 
          iprot.readListEnd()
8345 
        else:
8346 
          iprot.skip(ftype)
8347 
      elif fid == 1:
8348 
        if ftype == TType.STRUCT:
8349 
          self.isex = CatalogServiceException()
8350 
          self.isex.read(iprot)
8351 
        else:
8352 
          iprot.skip(ftype)
8353 
      else:
8354 
        iprot.skip(ftype)
8355 
      iprot.readFieldEnd()
8356 
    iprot.readStructEnd()
8357 
 
8358 
  def write(self, oprot):
8359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8361 
      return
8362 
    oprot.writeStructBegin('getBestDeals_result')
8363 
    if self.success is not None:
8364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8366 
      for iter94 in self.success:
8367 
        iter94.write(oprot)
5944 mandeep.dh 8368 
      oprot.writeListEnd()
8369 
      oprot.writeFieldEnd()
8370 
    if self.isex is not None:
8371 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8372 
      self.isex.write(oprot)
8373 
      oprot.writeFieldEnd()
8374 
    oprot.writeFieldStop()
8375 
    oprot.writeStructEnd()
8376 
 
8377 
  def validate(self):
8378 
    return
8379 
 
8380 
 
8381 
  def __repr__(self):
8382 
    L = ['%s=%r' % (key, value)
8383 
      for key, value in self.__dict__.iteritems()]
8384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8385 
 
8386 
  def __eq__(self, other):
8387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8388 
 
8389 
  def __ne__(self, other):
8390 
    return not (self == other)
8391 
 
8392 
class getBestDealsCatalogIds_args:
8393 
  """
8394 
  Attributes:
8395 
   - beginIndex
8396 
   - totalItems
8397 
   - brand
8398 
   - category
8399 
  """
8400 
 
8401 
  thrift_spec = (
8402 
    None, # 0
8403 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8404 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8405 
    (3, TType.STRING, 'brand', None, None, ), # 3
8406 
    (4, TType.I64, 'category', None, None, ), # 4
8407 
  )
8408 
 
8409 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8410 
    self.beginIndex = beginIndex
8411 
    self.totalItems = totalItems
8412 
    self.brand = brand
8413 
    self.category = category
8414 
 
8415 
  def read(self, iprot):
8416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8418 
      return
8419 
    iprot.readStructBegin()
8420 
    while True:
8421 
      (fname, ftype, fid) = iprot.readFieldBegin()
8422 
      if ftype == TType.STOP:
8423 
        break
8424 
      if fid == 1:
8425 
        if ftype == TType.I64:
8426 
          self.beginIndex = iprot.readI64();
8427 
        else:
8428 
          iprot.skip(ftype)
8429 
      elif fid == 2:
8430 
        if ftype == TType.I64:
8431 
          self.totalItems = iprot.readI64();
8432 
        else:
8433 
          iprot.skip(ftype)
8434 
      elif fid == 3:
8435 
        if ftype == TType.STRING:
8436 
          self.brand = iprot.readString();
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      elif fid == 4:
8440 
        if ftype == TType.I64:
8441 
          self.category = iprot.readI64();
8442 
        else:
8443 
          iprot.skip(ftype)
8444 
      else:
8445 
        iprot.skip(ftype)
8446 
      iprot.readFieldEnd()
8447 
    iprot.readStructEnd()
8448 
 
8449 
  def write(self, oprot):
8450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8452 
      return
8453 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8454 
    if self.beginIndex is not None:
8455 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8456 
      oprot.writeI64(self.beginIndex)
8457 
      oprot.writeFieldEnd()
8458 
    if self.totalItems is not None:
8459 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8460 
      oprot.writeI64(self.totalItems)
8461 
      oprot.writeFieldEnd()
8462 
    if self.brand is not None:
8463 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8464 
      oprot.writeString(self.brand)
8465 
      oprot.writeFieldEnd()
8466 
    if self.category is not None:
8467 
      oprot.writeFieldBegin('category', TType.I64, 4)
8468 
      oprot.writeI64(self.category)
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 getBestDealsCatalogIds_result:
8489 
  """
8490 
  Attributes:
8491 
   - success
8492 
   - cex
8493 
  """
8494 
 
8495 
  thrift_spec = (
8496 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8497 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8498 
  )
8499 
 
8500 
  def __init__(self, success=None, cex=None,):
8501 
    self.success = success
8502 
    self.cex = cex
8503 
 
8504 
  def read(self, iprot):
8505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8507 
      return
8508 
    iprot.readStructBegin()
8509 
    while True:
8510 
      (fname, ftype, fid) = iprot.readFieldBegin()
8511 
      if ftype == TType.STOP:
8512 
        break
8513 
      if fid == 0:
8514 
        if ftype == TType.LIST:
8515 
          self.success = []
7438 amit.gupta 8516 
          (_etype98, _size95) = iprot.readListBegin()
8517 
          for _i99 in xrange(_size95):
8518 
            _elem100 = iprot.readI64();
8519 
            self.success.append(_elem100)
5944 mandeep.dh 8520 
          iprot.readListEnd()
8521 
        else:
8522 
          iprot.skip(ftype)
8523 
      elif fid == 1:
8524 
        if ftype == TType.STRUCT:
8525 
          self.cex = CatalogServiceException()
8526 
          self.cex.read(iprot)
8527 
        else:
8528 
          iprot.skip(ftype)
8529 
      else:
8530 
        iprot.skip(ftype)
8531 
      iprot.readFieldEnd()
8532 
    iprot.readStructEnd()
8533 
 
8534 
  def write(self, oprot):
8535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8537 
      return
8538 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8539 
    if self.success is not None:
8540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8541 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8542 
      for iter101 in self.success:
8543 
        oprot.writeI64(iter101)
5944 mandeep.dh 8544 
      oprot.writeListEnd()
8545 
      oprot.writeFieldEnd()
8546 
    if self.cex is not None:
8547 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8548 
      self.cex.write(oprot)
8549 
      oprot.writeFieldEnd()
8550 
    oprot.writeFieldStop()
8551 
    oprot.writeStructEnd()
8552 
 
8553 
  def validate(self):
8554 
    return
8555 
 
8556 
 
8557 
  def __repr__(self):
8558 
    L = ['%s=%r' % (key, value)
8559 
      for key, value in self.__dict__.iteritems()]
8560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8561 
 
8562 
  def __eq__(self, other):
8563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8564 
 
8565 
  def __ne__(self, other):
8566 
    return not (self == other)
8567 
 
8568 
class getBestDealsCount_args:
8569 
 
8570 
  thrift_spec = (
8571 
  )
8572 
 
8573 
  def read(self, iprot):
8574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8576 
      return
8577 
    iprot.readStructBegin()
8578 
    while True:
8579 
      (fname, ftype, fid) = iprot.readFieldBegin()
8580 
      if ftype == TType.STOP:
8581 
        break
8582 
      else:
8583 
        iprot.skip(ftype)
8584 
      iprot.readFieldEnd()
8585 
    iprot.readStructEnd()
8586 
 
8587 
  def write(self, oprot):
8588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8590 
      return
8591 
    oprot.writeStructBegin('getBestDealsCount_args')
8592 
    oprot.writeFieldStop()
8593 
    oprot.writeStructEnd()
8594 
 
8595 
  def validate(self):
8596 
    return
8597 
 
8598 
 
8599 
  def __repr__(self):
8600 
    L = ['%s=%r' % (key, value)
8601 
      for key, value in self.__dict__.iteritems()]
8602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8603 
 
8604 
  def __eq__(self, other):
8605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8606 
 
8607 
  def __ne__(self, other):
8608 
    return not (self == other)
8609 
 
8610 
class getBestDealsCount_result:
8611 
  """
8612 
  Attributes:
8613 
   - success
8614 
   - cex
8615 
  """
8616 
 
8617 
  thrift_spec = (
8618 
    (0, TType.I64, 'success', None, None, ), # 0
8619 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8620 
  )
8621 
 
8622 
  def __init__(self, success=None, cex=None,):
8623 
    self.success = success
8624 
    self.cex = cex
8625 
 
8626 
  def read(self, iprot):
8627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8629 
      return
8630 
    iprot.readStructBegin()
8631 
    while True:
8632 
      (fname, ftype, fid) = iprot.readFieldBegin()
8633 
      if ftype == TType.STOP:
8634 
        break
8635 
      if fid == 0:
8636 
        if ftype == TType.I64:
8637 
          self.success = iprot.readI64();
8638 
        else:
8639 
          iprot.skip(ftype)
8640 
      elif fid == 1:
8641 
        if ftype == TType.STRUCT:
8642 
          self.cex = CatalogServiceException()
8643 
          self.cex.read(iprot)
8644 
        else:
8645 
          iprot.skip(ftype)
8646 
      else:
8647 
        iprot.skip(ftype)
8648 
      iprot.readFieldEnd()
8649 
    iprot.readStructEnd()
8650 
 
8651 
  def write(self, oprot):
8652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8654 
      return
8655 
    oprot.writeStructBegin('getBestDealsCount_result')
8656 
    if self.success is not None:
8657 
      oprot.writeFieldBegin('success', TType.I64, 0)
8658 
      oprot.writeI64(self.success)
8659 
      oprot.writeFieldEnd()
8660 
    if self.cex is not None:
8661 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8662 
      self.cex.write(oprot)
8663 
      oprot.writeFieldEnd()
8664 
    oprot.writeFieldStop()
8665 
    oprot.writeStructEnd()
8666 
 
8667 
  def validate(self):
8668 
    return
8669 
 
8670 
 
8671 
  def __repr__(self):
8672 
    L = ['%s=%r' % (key, value)
8673 
      for key, value in self.__dict__.iteritems()]
8674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8675 
 
8676 
  def __eq__(self, other):
8677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8678 
 
8679 
  def __ne__(self, other):
8680 
    return not (self == other)
8681 
 
8682 
class getComingSoon_args:
8683 
 
8684 
  thrift_spec = (
8685 
  )
8686 
 
8687 
  def read(self, iprot):
8688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8690 
      return
8691 
    iprot.readStructBegin()
8692 
    while True:
8693 
      (fname, ftype, fid) = iprot.readFieldBegin()
8694 
      if ftype == TType.STOP:
8695 
        break
8696 
      else:
8697 
        iprot.skip(ftype)
8698 
      iprot.readFieldEnd()
8699 
    iprot.readStructEnd()
8700 
 
8701 
  def write(self, oprot):
8702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8704 
      return
8705 
    oprot.writeStructBegin('getComingSoon_args')
8706 
    oprot.writeFieldStop()
8707 
    oprot.writeStructEnd()
8708 
 
8709 
  def validate(self):
8710 
    return
8711 
 
8712 
 
8713 
  def __repr__(self):
8714 
    L = ['%s=%r' % (key, value)
8715 
      for key, value in self.__dict__.iteritems()]
8716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8717 
 
8718 
  def __eq__(self, other):
8719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8720 
 
8721 
  def __ne__(self, other):
8722 
    return not (self == other)
8723 
 
8724 
class getComingSoon_result:
8725 
  """
8726 
  Attributes:
8727 
   - success
8728 
   - isex
8729 
  """
8730 
 
8731 
  thrift_spec = (
8732 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8733 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8734 
  )
8735 
 
8736 
  def __init__(self, success=None, isex=None,):
8737 
    self.success = success
8738 
    self.isex = isex
8739 
 
8740 
  def read(self, iprot):
8741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8743 
      return
8744 
    iprot.readStructBegin()
8745 
    while True:
8746 
      (fname, ftype, fid) = iprot.readFieldBegin()
8747 
      if ftype == TType.STOP:
8748 
        break
8749 
      if fid == 0:
8750 
        if ftype == TType.LIST:
8751 
          self.success = []
7438 amit.gupta 8752 
          (_etype105, _size102) = iprot.readListBegin()
8753 
          for _i106 in xrange(_size102):
8754 
            _elem107 = Item()
8755 
            _elem107.read(iprot)
8756 
            self.success.append(_elem107)
5944 mandeep.dh 8757 
          iprot.readListEnd()
8758 
        else:
8759 
          iprot.skip(ftype)
8760 
      elif fid == 1:
8761 
        if ftype == TType.STRUCT:
8762 
          self.isex = CatalogServiceException()
8763 
          self.isex.read(iprot)
8764 
        else:
8765 
          iprot.skip(ftype)
8766 
      else:
8767 
        iprot.skip(ftype)
8768 
      iprot.readFieldEnd()
8769 
    iprot.readStructEnd()
8770 
 
8771 
  def write(self, oprot):
8772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8774 
      return
8775 
    oprot.writeStructBegin('getComingSoon_result')
8776 
    if self.success is not None:
8777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8779 
      for iter108 in self.success:
8780 
        iter108.write(oprot)
5944 mandeep.dh 8781 
      oprot.writeListEnd()
8782 
      oprot.writeFieldEnd()
8783 
    if self.isex is not None:
8784 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8785 
      self.isex.write(oprot)
8786 
      oprot.writeFieldEnd()
8787 
    oprot.writeFieldStop()
8788 
    oprot.writeStructEnd()
8789 
 
8790 
  def validate(self):
8791 
    return
8792 
 
8793 
 
8794 
  def __repr__(self):
8795 
    L = ['%s=%r' % (key, value)
8796 
      for key, value in self.__dict__.iteritems()]
8797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8798 
 
8799 
  def __eq__(self, other):
8800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8801 
 
8802 
  def __ne__(self, other):
8803 
    return not (self == other)
8804 
 
8805 
class getComingSoonCatalogIds_args:
8806 
  """
8807 
  Attributes:
8808 
   - beginIndex
8809 
   - totalItems
8810 
   - brand
8811 
   - category
8812 
  """
8813 
 
8814 
  thrift_spec = (
8815 
    None, # 0
8816 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8817 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8818 
    (3, TType.STRING, 'brand', None, None, ), # 3
8819 
    (4, TType.I64, 'category', None, None, ), # 4
8820 
  )
8821 
 
8822 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8823 
    self.beginIndex = beginIndex
8824 
    self.totalItems = totalItems
8825 
    self.brand = brand
8826 
    self.category = category
8827 
 
8828 
  def read(self, iprot):
8829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8831 
      return
8832 
    iprot.readStructBegin()
8833 
    while True:
8834 
      (fname, ftype, fid) = iprot.readFieldBegin()
8835 
      if ftype == TType.STOP:
8836 
        break
8837 
      if fid == 1:
8838 
        if ftype == TType.I64:
8839 
          self.beginIndex = iprot.readI64();
8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      elif fid == 2:
8843 
        if ftype == TType.I64:
8844 
          self.totalItems = iprot.readI64();
8845 
        else:
8846 
          iprot.skip(ftype)
8847 
      elif fid == 3:
8848 
        if ftype == TType.STRING:
8849 
          self.brand = iprot.readString();
8850 
        else:
8851 
          iprot.skip(ftype)
8852 
      elif fid == 4:
8853 
        if ftype == TType.I64:
8854 
          self.category = iprot.readI64();
8855 
        else:
8856 
          iprot.skip(ftype)
8857 
      else:
8858 
        iprot.skip(ftype)
8859 
      iprot.readFieldEnd()
8860 
    iprot.readStructEnd()
8861 
 
8862 
  def write(self, oprot):
8863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8865 
      return
8866 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8867 
    if self.beginIndex is not None:
8868 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8869 
      oprot.writeI64(self.beginIndex)
8870 
      oprot.writeFieldEnd()
8871 
    if self.totalItems is not None:
8872 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8873 
      oprot.writeI64(self.totalItems)
8874 
      oprot.writeFieldEnd()
8875 
    if self.brand is not None:
8876 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8877 
      oprot.writeString(self.brand)
8878 
      oprot.writeFieldEnd()
8879 
    if self.category is not None:
8880 
      oprot.writeFieldBegin('category', TType.I64, 4)
8881 
      oprot.writeI64(self.category)
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 getComingSoonCatalogIds_result:
8902 
  """
8903 
  Attributes:
8904 
   - success
8905 
   - cex
8906 
  """
8907 
 
8908 
  thrift_spec = (
8909 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8910 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8911 
  )
8912 
 
8913 
  def __init__(self, success=None, cex=None,):
8914 
    self.success = success
8915 
    self.cex = cex
8916 
 
8917 
  def read(self, iprot):
8918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8920 
      return
8921 
    iprot.readStructBegin()
8922 
    while True:
8923 
      (fname, ftype, fid) = iprot.readFieldBegin()
8924 
      if ftype == TType.STOP:
8925 
        break
8926 
      if fid == 0:
8927 
        if ftype == TType.LIST:
8928 
          self.success = []
7438 amit.gupta 8929 
          (_etype112, _size109) = iprot.readListBegin()
8930 
          for _i113 in xrange(_size109):
8931 
            _elem114 = iprot.readI64();
8932 
            self.success.append(_elem114)
5944 mandeep.dh 8933 
          iprot.readListEnd()
8934 
        else:
8935 
          iprot.skip(ftype)
8936 
      elif fid == 1:
8937 
        if ftype == TType.STRUCT:
8938 
          self.cex = CatalogServiceException()
8939 
          self.cex.read(iprot)
8940 
        else:
8941 
          iprot.skip(ftype)
8942 
      else:
8943 
        iprot.skip(ftype)
8944 
      iprot.readFieldEnd()
8945 
    iprot.readStructEnd()
8946 
 
8947 
  def write(self, oprot):
8948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8950 
      return
8951 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8952 
    if self.success is not None:
8953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8954 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8955 
      for iter115 in self.success:
8956 
        oprot.writeI64(iter115)
5944 mandeep.dh 8957 
      oprot.writeListEnd()
8958 
      oprot.writeFieldEnd()
8959 
    if self.cex is not None:
8960 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8961 
      self.cex.write(oprot)
8962 
      oprot.writeFieldEnd()
8963 
    oprot.writeFieldStop()
8964 
    oprot.writeStructEnd()
8965 
 
8966 
  def validate(self):
8967 
    return
8968 
 
8969 
 
8970 
  def __repr__(self):
8971 
    L = ['%s=%r' % (key, value)
8972 
      for key, value in self.__dict__.iteritems()]
8973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8974 
 
8975 
  def __eq__(self, other):
8976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8977 
 
8978 
  def __ne__(self, other):
8979 
    return not (self == other)
8980 
 
8981 
class getComingSoonCount_args:
8982 
 
8983 
  thrift_spec = (
8984 
  )
8985 
 
8986 
  def read(self, iprot):
8987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8989 
      return
8990 
    iprot.readStructBegin()
8991 
    while True:
8992 
      (fname, ftype, fid) = iprot.readFieldBegin()
8993 
      if ftype == TType.STOP:
8994 
        break
8995 
      else:
8996 
        iprot.skip(ftype)
8997 
      iprot.readFieldEnd()
8998 
    iprot.readStructEnd()
8999 
 
9000 
  def write(self, oprot):
9001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9003 
      return
9004 
    oprot.writeStructBegin('getComingSoonCount_args')
9005 
    oprot.writeFieldStop()
9006 
    oprot.writeStructEnd()
9007 
 
9008 
  def validate(self):
9009 
    return
9010 
 
9011 
 
9012 
  def __repr__(self):
9013 
    L = ['%s=%r' % (key, value)
9014 
      for key, value in self.__dict__.iteritems()]
9015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9016 
 
9017 
  def __eq__(self, other):
9018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9019 
 
9020 
  def __ne__(self, other):
9021 
    return not (self == other)
9022 
 
9023 
class getComingSoonCount_result:
9024 
  """
9025 
  Attributes:
9026 
   - success
9027 
   - cex
9028 
  """
9029 
 
9030 
  thrift_spec = (
9031 
    (0, TType.I64, 'success', None, None, ), # 0
9032 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9033 
  )
9034 
 
9035 
  def __init__(self, success=None, cex=None,):
9036 
    self.success = success
9037 
    self.cex = cex
9038 
 
9039 
  def read(self, iprot):
9040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9042 
      return
9043 
    iprot.readStructBegin()
9044 
    while True:
9045 
      (fname, ftype, fid) = iprot.readFieldBegin()
9046 
      if ftype == TType.STOP:
9047 
        break
9048 
      if fid == 0:
9049 
        if ftype == TType.I64:
9050 
          self.success = iprot.readI64();
9051 
        else:
9052 
          iprot.skip(ftype)
9053 
      elif fid == 1:
9054 
        if ftype == TType.STRUCT:
9055 
          self.cex = CatalogServiceException()
9056 
          self.cex.read(iprot)
9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      else:
9060 
        iprot.skip(ftype)
9061 
      iprot.readFieldEnd()
9062 
    iprot.readStructEnd()
9063 
 
9064 
  def write(self, oprot):
9065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9067 
      return
9068 
    oprot.writeStructBegin('getComingSoonCount_result')
9069 
    if self.success is not None:
9070 
      oprot.writeFieldBegin('success', TType.I64, 0)
9071 
      oprot.writeI64(self.success)
9072 
      oprot.writeFieldEnd()
9073 
    if self.cex is not None:
9074 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9075 
      self.cex.write(oprot)
9076 
      oprot.writeFieldEnd()
9077 
    oprot.writeFieldStop()
9078 
    oprot.writeStructEnd()
9079 
 
9080 
  def validate(self):
9081 
    return
9082 
 
9083 
 
9084 
  def __repr__(self):
9085 
    L = ['%s=%r' % (key, value)
9086 
      for key, value in self.__dict__.iteritems()]
9087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9088 
 
9089 
  def __eq__(self, other):
9090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9091 
 
9092 
  def __ne__(self, other):
9093 
    return not (self == other)
9094 
 
9095 
class getLatestArrivals_args:
9096 
 
9097 
  thrift_spec = (
9098 
  )
9099 
 
9100 
  def read(self, iprot):
9101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9103 
      return
9104 
    iprot.readStructBegin()
9105 
    while True:
9106 
      (fname, ftype, fid) = iprot.readFieldBegin()
9107 
      if ftype == TType.STOP:
9108 
        break
9109 
      else:
9110 
        iprot.skip(ftype)
9111 
      iprot.readFieldEnd()
9112 
    iprot.readStructEnd()
9113 
 
9114 
  def write(self, oprot):
9115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9117 
      return
9118 
    oprot.writeStructBegin('getLatestArrivals_args')
9119 
    oprot.writeFieldStop()
9120 
    oprot.writeStructEnd()
9121 
 
9122 
  def validate(self):
9123 
    return
9124 
 
9125 
 
9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
9137 
class getLatestArrivals_result:
9138 
  """
9139 
  Attributes:
9140 
   - success
9141 
   - isex
9142 
  """
9143 
 
9144 
  thrift_spec = (
9145 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9146 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9147 
  )
9148 
 
9149 
  def __init__(self, success=None, isex=None,):
9150 
    self.success = success
9151 
    self.isex = isex
9152 
 
9153 
  def read(self, iprot):
9154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9156 
      return
9157 
    iprot.readStructBegin()
9158 
    while True:
9159 
      (fname, ftype, fid) = iprot.readFieldBegin()
9160 
      if ftype == TType.STOP:
9161 
        break
9162 
      if fid == 0:
9163 
        if ftype == TType.LIST:
9164 
          self.success = []
7438 amit.gupta 9165 
          (_etype119, _size116) = iprot.readListBegin()
9166 
          for _i120 in xrange(_size116):
9167 
            _elem121 = Item()
9168 
            _elem121.read(iprot)
9169 
            self.success.append(_elem121)
5944 mandeep.dh 9170 
          iprot.readListEnd()
9171 
        else:
9172 
          iprot.skip(ftype)
9173 
      elif fid == 1:
9174 
        if ftype == TType.STRUCT:
9175 
          self.isex = CatalogServiceException()
9176 
          self.isex.read(iprot)
9177 
        else:
9178 
          iprot.skip(ftype)
9179 
      else:
9180 
        iprot.skip(ftype)
9181 
      iprot.readFieldEnd()
9182 
    iprot.readStructEnd()
9183 
 
9184 
  def write(self, oprot):
9185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9187 
      return
9188 
    oprot.writeStructBegin('getLatestArrivals_result')
9189 
    if self.success is not None:
9190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9192 
      for iter122 in self.success:
9193 
        iter122.write(oprot)
5944 mandeep.dh 9194 
      oprot.writeListEnd()
9195 
      oprot.writeFieldEnd()
9196 
    if self.isex is not None:
9197 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9198 
      self.isex.write(oprot)
9199 
      oprot.writeFieldEnd()
9200 
    oprot.writeFieldStop()
9201 
    oprot.writeStructEnd()
9202 
 
9203 
  def validate(self):
9204 
    return
9205 
 
9206 
 
9207 
  def __repr__(self):
9208 
    L = ['%s=%r' % (key, value)
9209 
      for key, value in self.__dict__.iteritems()]
9210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9211 
 
9212 
  def __eq__(self, other):
9213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9214 
 
9215 
  def __ne__(self, other):
9216 
    return not (self == other)
9217 
 
9218 
class getLatestArrivalsCatalogIds_args:
9219 
  """
9220 
  Attributes:
9221 
   - beginIndex
9222 
   - totalItems
9223 
   - brand
9224 
   - categories
9225 
  """
9226 
 
9227 
  thrift_spec = (
9228 
    None, # 0
9229 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9230 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9231 
    (3, TType.STRING, 'brand', None, None, ), # 3
9232 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9233 
  )
9234 
 
9235 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9236 
    self.beginIndex = beginIndex
9237 
    self.totalItems = totalItems
9238 
    self.brand = brand
9239 
    self.categories = categories
9240 
 
9241 
  def read(self, iprot):
9242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9244 
      return
9245 
    iprot.readStructBegin()
9246 
    while True:
9247 
      (fname, ftype, fid) = iprot.readFieldBegin()
9248 
      if ftype == TType.STOP:
9249 
        break
9250 
      if fid == 1:
9251 
        if ftype == TType.I64:
9252 
          self.beginIndex = iprot.readI64();
9253 
        else:
9254 
          iprot.skip(ftype)
9255 
      elif fid == 2:
9256 
        if ftype == TType.I64:
9257 
          self.totalItems = iprot.readI64();
9258 
        else:
9259 
          iprot.skip(ftype)
9260 
      elif fid == 3:
9261 
        if ftype == TType.STRING:
9262 
          self.brand = iprot.readString();
9263 
        else:
9264 
          iprot.skip(ftype)
9265 
      elif fid == 4:
9266 
        if ftype == TType.LIST:
9267 
          self.categories = []
7438 amit.gupta 9268 
          (_etype126, _size123) = iprot.readListBegin()
9269 
          for _i127 in xrange(_size123):
9270 
            _elem128 = iprot.readI64();
9271 
            self.categories.append(_elem128)
5944 mandeep.dh 9272 
          iprot.readListEnd()
9273 
        else:
9274 
          iprot.skip(ftype)
9275 
      else:
9276 
        iprot.skip(ftype)
9277 
      iprot.readFieldEnd()
9278 
    iprot.readStructEnd()
9279 
 
9280 
  def write(self, oprot):
9281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9283 
      return
9284 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9285 
    if self.beginIndex is not None:
9286 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9287 
      oprot.writeI64(self.beginIndex)
9288 
      oprot.writeFieldEnd()
9289 
    if self.totalItems is not None:
9290 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9291 
      oprot.writeI64(self.totalItems)
9292 
      oprot.writeFieldEnd()
9293 
    if self.brand is not None:
9294 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9295 
      oprot.writeString(self.brand)
9296 
      oprot.writeFieldEnd()
9297 
    if self.categories is not None:
9298 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9299 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9300 
      for iter129 in self.categories:
9301 
        oprot.writeI64(iter129)
5944 mandeep.dh 9302 
      oprot.writeListEnd()
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 getLatestArrivalsCatalogIds_result:
9323 
  """
9324 
  Attributes:
9325 
   - success
9326 
   - cex
9327 
  """
9328 
 
9329 
  thrift_spec = (
9330 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9331 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9332 
  )
9333 
 
9334 
  def __init__(self, success=None, cex=None,):
9335 
    self.success = success
9336 
    self.cex = cex
9337 
 
9338 
  def read(self, iprot):
9339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9341 
      return
9342 
    iprot.readStructBegin()
9343 
    while True:
9344 
      (fname, ftype, fid) = iprot.readFieldBegin()
9345 
      if ftype == TType.STOP:
9346 
        break
9347 
      if fid == 0:
9348 
        if ftype == TType.LIST:
9349 
          self.success = []
7438 amit.gupta 9350 
          (_etype133, _size130) = iprot.readListBegin()
9351 
          for _i134 in xrange(_size130):
9352 
            _elem135 = iprot.readI64();
9353 
            self.success.append(_elem135)
5944 mandeep.dh 9354 
          iprot.readListEnd()
9355 
        else:
9356 
          iprot.skip(ftype)
9357 
      elif fid == 1:
9358 
        if ftype == TType.STRUCT:
9359 
          self.cex = CatalogServiceException()
9360 
          self.cex.read(iprot)
9361 
        else:
9362 
          iprot.skip(ftype)
9363 
      else:
9364 
        iprot.skip(ftype)
9365 
      iprot.readFieldEnd()
9366 
    iprot.readStructEnd()
9367 
 
9368 
  def write(self, oprot):
9369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9371 
      return
9372 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9373 
    if self.success is not None:
9374 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9375 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9376 
      for iter136 in self.success:
9377 
        oprot.writeI64(iter136)
5944 mandeep.dh 9378 
      oprot.writeListEnd()
9379 
      oprot.writeFieldEnd()
9380 
    if self.cex is not None:
9381 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9382 
      self.cex.write(oprot)
9383 
      oprot.writeFieldEnd()
9384 
    oprot.writeFieldStop()
9385 
    oprot.writeStructEnd()
9386 
 
9387 
  def validate(self):
9388 
    return
9389 
 
9390 
 
9391 
  def __repr__(self):
9392 
    L = ['%s=%r' % (key, value)
9393 
      for key, value in self.__dict__.iteritems()]
9394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9395 
 
9396 
  def __eq__(self, other):
9397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9398 
 
9399 
  def __ne__(self, other):
9400 
    return not (self == other)
9401 
 
9402 
class getLatestArrivalsCount_args:
9403 
 
9404 
  thrift_spec = (
9405 
  )
9406 
 
9407 
  def read(self, iprot):
9408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9410 
      return
9411 
    iprot.readStructBegin()
9412 
    while True:
9413 
      (fname, ftype, fid) = iprot.readFieldBegin()
9414 
      if ftype == TType.STOP:
9415 
        break
9416 
      else:
9417 
        iprot.skip(ftype)
9418 
      iprot.readFieldEnd()
9419 
    iprot.readStructEnd()
9420 
 
9421 
  def write(self, oprot):
9422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9424 
      return
9425 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9426 
    oprot.writeFieldStop()
9427 
    oprot.writeStructEnd()
9428 
 
9429 
  def validate(self):
9430 
    return
9431 
 
9432 
 
9433 
  def __repr__(self):
9434 
    L = ['%s=%r' % (key, value)
9435 
      for key, value in self.__dict__.iteritems()]
9436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9437 
 
9438 
  def __eq__(self, other):
9439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9440 
 
9441 
  def __ne__(self, other):
9442 
    return not (self == other)
9443 
 
9444 
class getLatestArrivalsCount_result:
9445 
  """
9446 
  Attributes:
9447 
   - success
9448 
   - cex
9449 
  """
9450 
 
9451 
  thrift_spec = (
9452 
    (0, TType.I64, 'success', None, None, ), # 0
9453 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9454 
  )
9455 
 
9456 
  def __init__(self, success=None, cex=None,):
9457 
    self.success = success
9458 
    self.cex = cex
9459 
 
9460 
  def read(self, iprot):
9461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9463 
      return
9464 
    iprot.readStructBegin()
9465 
    while True:
9466 
      (fname, ftype, fid) = iprot.readFieldBegin()
9467 
      if ftype == TType.STOP:
9468 
        break
9469 
      if fid == 0:
9470 
        if ftype == TType.I64:
9471 
          self.success = iprot.readI64();
9472 
        else:
9473 
          iprot.skip(ftype)
9474 
      elif fid == 1:
9475 
        if ftype == TType.STRUCT:
9476 
          self.cex = CatalogServiceException()
9477 
          self.cex.read(iprot)
9478 
        else:
9479 
          iprot.skip(ftype)
9480 
      else:
9481 
        iprot.skip(ftype)
9482 
      iprot.readFieldEnd()
9483 
    iprot.readStructEnd()
9484 
 
9485 
  def write(self, oprot):
9486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9488 
      return
9489 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9490 
    if self.success is not None:
9491 
      oprot.writeFieldBegin('success', TType.I64, 0)
9492 
      oprot.writeI64(self.success)
9493 
      oprot.writeFieldEnd()
9494 
    if self.cex is not None:
9495 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9496 
      self.cex.write(oprot)
9497 
      oprot.writeFieldEnd()
9498 
    oprot.writeFieldStop()
9499 
    oprot.writeStructEnd()
9500 
 
9501 
  def validate(self):
9502 
    return
9503 
 
9504 
 
9505 
  def __repr__(self):
9506 
    L = ['%s=%r' % (key, value)
9507 
      for key, value in self.__dict__.iteritems()]
9508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9509 
 
9510 
  def __eq__(self, other):
9511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9512 
 
9513 
  def __ne__(self, other):
9514 
    return not (self == other)
9515 
 
9516 
class generateNewEntityID_args:
9517 
 
9518 
  thrift_spec = (
9519 
  )
9520 
 
9521 
  def read(self, iprot):
9522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9524 
      return
9525 
    iprot.readStructBegin()
9526 
    while True:
9527 
      (fname, ftype, fid) = iprot.readFieldBegin()
9528 
      if ftype == TType.STOP:
9529 
        break
9530 
      else:
9531 
        iprot.skip(ftype)
9532 
      iprot.readFieldEnd()
9533 
    iprot.readStructEnd()
9534 
 
9535 
  def write(self, oprot):
9536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9538 
      return
9539 
    oprot.writeStructBegin('generateNewEntityID_args')
9540 
    oprot.writeFieldStop()
9541 
    oprot.writeStructEnd()
9542 
 
9543 
  def validate(self):
9544 
    return
9545 
 
9546 
 
9547 
  def __repr__(self):
9548 
    L = ['%s=%r' % (key, value)
9549 
      for key, value in self.__dict__.iteritems()]
9550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9551 
 
9552 
  def __eq__(self, other):
9553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9554 
 
9555 
  def __ne__(self, other):
9556 
    return not (self == other)
9557 
 
9558 
class generateNewEntityID_result:
9559 
  """
9560 
  Attributes:
9561 
   - success
9562 
  """
9563 
 
9564 
  thrift_spec = (
9565 
    (0, TType.I64, 'success', None, None, ), # 0
9566 
  )
9567 
 
9568 
  def __init__(self, success=None,):
9569 
    self.success = success
9570 
 
9571 
  def read(self, iprot):
9572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9574 
      return
9575 
    iprot.readStructBegin()
9576 
    while True:
9577 
      (fname, ftype, fid) = iprot.readFieldBegin()
9578 
      if ftype == TType.STOP:
9579 
        break
9580 
      if fid == 0:
9581 
        if ftype == TType.I64:
9582 
          self.success = iprot.readI64();
9583 
        else:
9584 
          iprot.skip(ftype)
9585 
      else:
9586 
        iprot.skip(ftype)
9587 
      iprot.readFieldEnd()
9588 
    iprot.readStructEnd()
9589 
 
9590 
  def write(self, oprot):
9591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9593 
      return
9594 
    oprot.writeStructBegin('generateNewEntityID_result')
9595 
    if self.success is not None:
9596 
      oprot.writeFieldBegin('success', TType.I64, 0)
9597 
      oprot.writeI64(self.success)
9598 
      oprot.writeFieldEnd()
9599 
    oprot.writeFieldStop()
9600 
    oprot.writeStructEnd()
9601 
 
9602 
  def validate(self):
9603 
    return
9604 
 
9605 
 
9606 
  def __repr__(self):
9607 
    L = ['%s=%r' % (key, value)
9608 
      for key, value in self.__dict__.iteritems()]
9609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9610 
 
9611 
  def __eq__(self, other):
9612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9613 
 
9614 
  def __ne__(self, other):
9615 
    return not (self == other)
9616 
 
9617 
class addCategory_args:
9618 
  """
9619 
  Attributes:
9620 
   - category
9621 
  """
9622 
 
9623 
  thrift_spec = (
9624 
    None, # 0
9625 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9626 
  )
9627 
 
9628 
  def __init__(self, category=None,):
9629 
    self.category = category
9630 
 
9631 
  def read(self, iprot):
9632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9634 
      return
9635 
    iprot.readStructBegin()
9636 
    while True:
9637 
      (fname, ftype, fid) = iprot.readFieldBegin()
9638 
      if ftype == TType.STOP:
9639 
        break
9640 
      if fid == 1:
9641 
        if ftype == TType.STRUCT:
9642 
          self.category = Category()
9643 
          self.category.read(iprot)
9644 
        else:
9645 
          iprot.skip(ftype)
9646 
      else:
9647 
        iprot.skip(ftype)
9648 
      iprot.readFieldEnd()
9649 
    iprot.readStructEnd()
9650 
 
9651 
  def write(self, oprot):
9652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9654 
      return
9655 
    oprot.writeStructBegin('addCategory_args')
9656 
    if self.category is not None:
9657 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9658 
      self.category.write(oprot)
9659 
      oprot.writeFieldEnd()
9660 
    oprot.writeFieldStop()
9661 
    oprot.writeStructEnd()
9662 
 
9663 
  def validate(self):
9664 
    return
9665 
 
9666 
 
9667 
  def __repr__(self):
9668 
    L = ['%s=%r' % (key, value)
9669 
      for key, value in self.__dict__.iteritems()]
9670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9671 
 
9672 
  def __eq__(self, other):
9673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9674 
 
9675 
  def __ne__(self, other):
9676 
    return not (self == other)
9677 
 
9678 
class addCategory_result:
9679 
  """
9680 
  Attributes:
9681 
   - success
9682 
  """
9683 
 
9684 
  thrift_spec = (
9685 
    (0, TType.BOOL, 'success', None, None, ), # 0
9686 
  )
9687 
 
9688 
  def __init__(self, success=None,):
9689 
    self.success = success
9690 
 
9691 
  def read(self, iprot):
9692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9694 
      return
9695 
    iprot.readStructBegin()
9696 
    while True:
9697 
      (fname, ftype, fid) = iprot.readFieldBegin()
9698 
      if ftype == TType.STOP:
9699 
        break
9700 
      if fid == 0:
9701 
        if ftype == TType.BOOL:
9702 
          self.success = iprot.readBool();
9703 
        else:
9704 
          iprot.skip(ftype)
9705 
      else:
9706 
        iprot.skip(ftype)
9707 
      iprot.readFieldEnd()
9708 
    iprot.readStructEnd()
9709 
 
9710 
  def write(self, oprot):
9711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9713 
      return
9714 
    oprot.writeStructBegin('addCategory_result')
9715 
    if self.success is not None:
9716 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9717 
      oprot.writeBool(self.success)
9718 
      oprot.writeFieldEnd()
9719 
    oprot.writeFieldStop()
9720 
    oprot.writeStructEnd()
9721 
 
9722 
  def validate(self):
9723 
    return
9724 
 
9725 
 
9726 
  def __repr__(self):
9727 
    L = ['%s=%r' % (key, value)
9728 
      for key, value in self.__dict__.iteritems()]
9729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9730 
 
9731 
  def __eq__(self, other):
9732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9733 
 
9734 
  def __ne__(self, other):
9735 
    return not (self == other)
9736 
 
9737 
class getCategory_args:
9738 
  """
9739 
  Attributes:
9740 
   - id
9741 
  """
9742 
 
9743 
  thrift_spec = (
9744 
    None, # 0
9745 
    (1, TType.I64, 'id', None, None, ), # 1
9746 
  )
9747 
 
9748 
  def __init__(self, id=None,):
9749 
    self.id = id
9750 
 
9751 
  def read(self, iprot):
9752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9754 
      return
9755 
    iprot.readStructBegin()
9756 
    while True:
9757 
      (fname, ftype, fid) = iprot.readFieldBegin()
9758 
      if ftype == TType.STOP:
9759 
        break
9760 
      if fid == 1:
9761 
        if ftype == TType.I64:
9762 
          self.id = iprot.readI64();
9763 
        else:
9764 
          iprot.skip(ftype)
9765 
      else:
9766 
        iprot.skip(ftype)
9767 
      iprot.readFieldEnd()
9768 
    iprot.readStructEnd()
9769 
 
9770 
  def write(self, oprot):
9771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9773 
      return
9774 
    oprot.writeStructBegin('getCategory_args')
9775 
    if self.id is not None:
9776 
      oprot.writeFieldBegin('id', TType.I64, 1)
9777 
      oprot.writeI64(self.id)
9778 
      oprot.writeFieldEnd()
9779 
    oprot.writeFieldStop()
9780 
    oprot.writeStructEnd()
9781 
 
9782 
  def validate(self):
9783 
    return
9784 
 
9785 
 
9786 
  def __repr__(self):
9787 
    L = ['%s=%r' % (key, value)
9788 
      for key, value in self.__dict__.iteritems()]
9789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9790 
 
9791 
  def __eq__(self, other):
9792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9793 
 
9794 
  def __ne__(self, other):
9795 
    return not (self == other)
9796 
 
9797 
class getCategory_result:
9798 
  """
9799 
  Attributes:
9800 
   - success
9801 
  """
9802 
 
9803 
  thrift_spec = (
9804 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9805 
  )
9806 
 
9807 
  def __init__(self, success=None,):
9808 
    self.success = success
9809 
 
9810 
  def read(self, iprot):
9811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9813 
      return
9814 
    iprot.readStructBegin()
9815 
    while True:
9816 
      (fname, ftype, fid) = iprot.readFieldBegin()
9817 
      if ftype == TType.STOP:
9818 
        break
9819 
      if fid == 0:
9820 
        if ftype == TType.STRUCT:
9821 
          self.success = Category()
9822 
          self.success.read(iprot)
9823 
        else:
9824 
          iprot.skip(ftype)
9825 
      else:
9826 
        iprot.skip(ftype)
9827 
      iprot.readFieldEnd()
9828 
    iprot.readStructEnd()
9829 
 
9830 
  def write(self, oprot):
9831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9833 
      return
9834 
    oprot.writeStructBegin('getCategory_result')
9835 
    if self.success is not None:
9836 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9837 
      self.success.write(oprot)
9838 
      oprot.writeFieldEnd()
9839 
    oprot.writeFieldStop()
9840 
    oprot.writeStructEnd()
9841 
 
9842 
  def validate(self):
9843 
    return
9844 
 
9845 
 
9846 
  def __repr__(self):
9847 
    L = ['%s=%r' % (key, value)
9848 
      for key, value in self.__dict__.iteritems()]
9849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9850 
 
9851 
  def __eq__(self, other):
9852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9853 
 
9854 
  def __ne__(self, other):
9855 
    return not (self == other)
9856 
 
9857 
class getAllCategories_args:
9858 
 
9859 
  thrift_spec = (
9860 
  )
9861 
 
9862 
  def read(self, iprot):
9863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9865 
      return
9866 
    iprot.readStructBegin()
9867 
    while True:
9868 
      (fname, ftype, fid) = iprot.readFieldBegin()
9869 
      if ftype == TType.STOP:
9870 
        break
9871 
      else:
9872 
        iprot.skip(ftype)
9873 
      iprot.readFieldEnd()
9874 
    iprot.readStructEnd()
9875 
 
9876 
  def write(self, oprot):
9877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9879 
      return
9880 
    oprot.writeStructBegin('getAllCategories_args')
9881 
    oprot.writeFieldStop()
9882 
    oprot.writeStructEnd()
9883 
 
9884 
  def validate(self):
9885 
    return
9886 
 
9887 
 
9888 
  def __repr__(self):
9889 
    L = ['%s=%r' % (key, value)
9890 
      for key, value in self.__dict__.iteritems()]
9891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9892 
 
9893 
  def __eq__(self, other):
9894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9895 
 
9896 
  def __ne__(self, other):
9897 
    return not (self == other)
9898 
 
9899 
class getAllCategories_result:
9900 
  """
9901 
  Attributes:
9902 
   - success
9903 
  """
9904 
 
9905 
  thrift_spec = (
9906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9907 
  )
9908 
 
9909 
  def __init__(self, success=None,):
9910 
    self.success = success
9911 
 
9912 
  def read(self, iprot):
9913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9915 
      return
9916 
    iprot.readStructBegin()
9917 
    while True:
9918 
      (fname, ftype, fid) = iprot.readFieldBegin()
9919 
      if ftype == TType.STOP:
9920 
        break
9921 
      if fid == 0:
9922 
        if ftype == TType.LIST:
9923 
          self.success = []
7438 amit.gupta 9924 
          (_etype140, _size137) = iprot.readListBegin()
9925 
          for _i141 in xrange(_size137):
9926 
            _elem142 = Category()
9927 
            _elem142.read(iprot)
9928 
            self.success.append(_elem142)
5944 mandeep.dh 9929 
          iprot.readListEnd()
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      else:
9933 
        iprot.skip(ftype)
9934 
      iprot.readFieldEnd()
9935 
    iprot.readStructEnd()
9936 
 
9937 
  def write(self, oprot):
9938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9940 
      return
9941 
    oprot.writeStructBegin('getAllCategories_result')
9942 
    if self.success is not None:
9943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9945 
      for iter143 in self.success:
9946 
        iter143.write(oprot)
5944 mandeep.dh 9947 
      oprot.writeListEnd()
9948 
      oprot.writeFieldEnd()
9949 
    oprot.writeFieldStop()
9950 
    oprot.writeStructEnd()
9951 
 
9952 
  def validate(self):
9953 
    return
9954 
 
9955 
 
9956 
  def __repr__(self):
9957 
    L = ['%s=%r' % (key, value)
9958 
      for key, value in self.__dict__.iteritems()]
9959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9960 
 
9961 
  def __eq__(self, other):
9962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9963 
 
9964 
  def __ne__(self, other):
9965 
    return not (self == other)
9966 
 
9967 
class getAllSimilarItems_args:
9968 
  """
9969 
  Attributes:
9970 
   - itemId
9971 
  """
9972 
 
9973 
  thrift_spec = (
9974 
    None, # 0
9975 
    (1, TType.I64, 'itemId', None, None, ), # 1
9976 
  )
9977 
 
9978 
  def __init__(self, itemId=None,):
9979 
    self.itemId = itemId
9980 
 
9981 
  def read(self, iprot):
9982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9984 
      return
9985 
    iprot.readStructBegin()
9986 
    while True:
9987 
      (fname, ftype, fid) = iprot.readFieldBegin()
9988 
      if ftype == TType.STOP:
9989 
        break
9990 
      if fid == 1:
9991 
        if ftype == TType.I64:
9992 
          self.itemId = iprot.readI64();
9993 
        else:
9994 
          iprot.skip(ftype)
9995 
      else:
9996 
        iprot.skip(ftype)
9997 
      iprot.readFieldEnd()
9998 
    iprot.readStructEnd()
9999 
 
10000 
  def write(self, oprot):
10001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10003 
      return
10004 
    oprot.writeStructBegin('getAllSimilarItems_args')
10005 
    if self.itemId is not None:
10006 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10007 
      oprot.writeI64(self.itemId)
10008 
      oprot.writeFieldEnd()
10009 
    oprot.writeFieldStop()
10010 
    oprot.writeStructEnd()
10011 
 
10012 
  def validate(self):
10013 
    return
10014 
 
10015 
 
10016 
  def __repr__(self):
10017 
    L = ['%s=%r' % (key, value)
10018 
      for key, value in self.__dict__.iteritems()]
10019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10020 
 
10021 
  def __eq__(self, other):
10022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10023 
 
10024 
  def __ne__(self, other):
10025 
    return not (self == other)
10026 
 
10027 
class getAllSimilarItems_result:
10028 
  """
10029 
  Attributes:
10030 
   - success
10031 
  """
10032 
 
10033 
  thrift_spec = (
10034 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10035 
  )
10036 
 
10037 
  def __init__(self, success=None,):
10038 
    self.success = success
10039 
 
10040 
  def read(self, iprot):
10041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10043 
      return
10044 
    iprot.readStructBegin()
10045 
    while True:
10046 
      (fname, ftype, fid) = iprot.readFieldBegin()
10047 
      if ftype == TType.STOP:
10048 
        break
10049 
      if fid == 0:
10050 
        if ftype == TType.LIST:
10051 
          self.success = []
7438 amit.gupta 10052 
          (_etype147, _size144) = iprot.readListBegin()
10053 
          for _i148 in xrange(_size144):
10054 
            _elem149 = Item()
10055 
            _elem149.read(iprot)
10056 
            self.success.append(_elem149)
5944 mandeep.dh 10057 
          iprot.readListEnd()
10058 
        else:
10059 
          iprot.skip(ftype)
10060 
      else:
10061 
        iprot.skip(ftype)
10062 
      iprot.readFieldEnd()
10063 
    iprot.readStructEnd()
10064 
 
10065 
  def write(self, oprot):
10066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10068 
      return
10069 
    oprot.writeStructBegin('getAllSimilarItems_result')
10070 
    if self.success is not None:
10071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10072 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10073 
      for iter150 in self.success:
10074 
        iter150.write(oprot)
5944 mandeep.dh 10075 
      oprot.writeListEnd()
10076 
      oprot.writeFieldEnd()
10077 
    oprot.writeFieldStop()
10078 
    oprot.writeStructEnd()
10079 
 
10080 
  def validate(self):
10081 
    return
10082 
 
10083 
 
10084 
  def __repr__(self):
10085 
    L = ['%s=%r' % (key, value)
10086 
      for key, value in self.__dict__.iteritems()]
10087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10088 
 
10089 
  def __eq__(self, other):
10090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10091 
 
10092 
  def __ne__(self, other):
10093 
    return not (self == other)
10094 
 
10095 
class addSimilarItem_args:
10096 
  """
10097 
  Attributes:
10098 
   - itemId
10099 
   - catalogItemId
10100 
  """
10101 
 
10102 
  thrift_spec = (
10103 
    None, # 0
10104 
    (1, TType.I64, 'itemId', None, None, ), # 1
10105 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10106 
  )
10107 
 
10108 
  def __init__(self, itemId=None, catalogItemId=None,):
10109 
    self.itemId = itemId
10110 
    self.catalogItemId = catalogItemId
10111 
 
10112 
  def read(self, iprot):
10113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10115 
      return
10116 
    iprot.readStructBegin()
10117 
    while True:
10118 
      (fname, ftype, fid) = iprot.readFieldBegin()
10119 
      if ftype == TType.STOP:
10120 
        break
10121 
      if fid == 1:
10122 
        if ftype == TType.I64:
10123 
          self.itemId = iprot.readI64();
10124 
        else:
10125 
          iprot.skip(ftype)
10126 
      elif fid == 2:
10127 
        if ftype == TType.I64:
10128 
          self.catalogItemId = iprot.readI64();
10129 
        else:
10130 
          iprot.skip(ftype)
10131 
      else:
10132 
        iprot.skip(ftype)
10133 
      iprot.readFieldEnd()
10134 
    iprot.readStructEnd()
10135 
 
10136 
  def write(self, oprot):
10137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10139 
      return
10140 
    oprot.writeStructBegin('addSimilarItem_args')
10141 
    if self.itemId is not None:
10142 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10143 
      oprot.writeI64(self.itemId)
10144 
      oprot.writeFieldEnd()
10145 
    if self.catalogItemId is not None:
10146 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10147 
      oprot.writeI64(self.catalogItemId)
10148 
      oprot.writeFieldEnd()
10149 
    oprot.writeFieldStop()
10150 
    oprot.writeStructEnd()
10151 
 
10152 
  def validate(self):
10153 
    return
10154 
 
10155 
 
10156 
  def __repr__(self):
10157 
    L = ['%s=%r' % (key, value)
10158 
      for key, value in self.__dict__.iteritems()]
10159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10160 
 
10161 
  def __eq__(self, other):
10162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10163 
 
10164 
  def __ne__(self, other):
10165 
    return not (self == other)
10166 
 
10167 
class addSimilarItem_result:
10168 
  """
10169 
  Attributes:
10170 
   - success
10171 
   - cex
10172 
  """
10173 
 
10174 
  thrift_spec = (
10175 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10176 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10177 
  )
10178 
 
10179 
  def __init__(self, success=None, cex=None,):
10180 
    self.success = success
10181 
    self.cex = cex
10182 
 
10183 
  def read(self, iprot):
10184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10186 
      return
10187 
    iprot.readStructBegin()
10188 
    while True:
10189 
      (fname, ftype, fid) = iprot.readFieldBegin()
10190 
      if ftype == TType.STOP:
10191 
        break
10192 
      if fid == 0:
10193 
        if ftype == TType.STRUCT:
10194 
          self.success = Item()
10195 
          self.success.read(iprot)
10196 
        else:
10197 
          iprot.skip(ftype)
10198 
      elif fid == 1:
10199 
        if ftype == TType.STRUCT:
10200 
          self.cex = CatalogServiceException()
10201 
          self.cex.read(iprot)
10202 
        else:
10203 
          iprot.skip(ftype)
10204 
      else:
10205 
        iprot.skip(ftype)
10206 
      iprot.readFieldEnd()
10207 
    iprot.readStructEnd()
10208 
 
10209 
  def write(self, oprot):
10210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10212 
      return
10213 
    oprot.writeStructBegin('addSimilarItem_result')
10214 
    if self.success is not None:
10215 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10216 
      self.success.write(oprot)
10217 
      oprot.writeFieldEnd()
10218 
    if self.cex is not None:
10219 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10220 
      self.cex.write(oprot)
10221 
      oprot.writeFieldEnd()
10222 
    oprot.writeFieldStop()
10223 
    oprot.writeStructEnd()
10224 
 
10225 
  def validate(self):
10226 
    return
10227 
 
10228 
 
10229 
  def __repr__(self):
10230 
    L = ['%s=%r' % (key, value)
10231 
      for key, value in self.__dict__.iteritems()]
10232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10233 
 
10234 
  def __eq__(self, other):
10235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10236 
 
10237 
  def __ne__(self, other):
10238 
    return not (self == other)
10239 
 
6512 kshitij.so 10240 
class addTag_args:
10241 
  """
10242 
  Attributes:
10243 
   - displayName
10244 
   - itemId
10245 
  """
10246 
 
10247 
  thrift_spec = (
10248 
    None, # 0
10249 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10250 
    (2, TType.I64, 'itemId', None, None, ), # 2
10251 
  )
10252 
 
10253 
  def __init__(self, displayName=None, itemId=None,):
10254 
    self.displayName = displayName
10255 
    self.itemId = itemId
10256 
 
10257 
  def read(self, iprot):
10258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10260 
      return
10261 
    iprot.readStructBegin()
10262 
    while True:
10263 
      (fname, ftype, fid) = iprot.readFieldBegin()
10264 
      if ftype == TType.STOP:
10265 
        break
10266 
      if fid == 1:
10267 
        if ftype == TType.STRING:
10268 
          self.displayName = iprot.readString();
10269 
        else:
10270 
          iprot.skip(ftype)
10271 
      elif fid == 2:
10272 
        if ftype == TType.I64:
10273 
          self.itemId = iprot.readI64();
10274 
        else:
10275 
          iprot.skip(ftype)
10276 
      else:
10277 
        iprot.skip(ftype)
10278 
      iprot.readFieldEnd()
10279 
    iprot.readStructEnd()
10280 
 
10281 
  def write(self, oprot):
10282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10284 
      return
10285 
    oprot.writeStructBegin('addTag_args')
10286 
    if self.displayName is not None:
10287 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10288 
      oprot.writeString(self.displayName)
10289 
      oprot.writeFieldEnd()
10290 
    if self.itemId is not None:
10291 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10292 
      oprot.writeI64(self.itemId)
10293 
      oprot.writeFieldEnd()
10294 
    oprot.writeFieldStop()
10295 
    oprot.writeStructEnd()
10296 
 
10297 
  def validate(self):
10298 
    return
10299 
 
10300 
 
10301 
  def __repr__(self):
10302 
    L = ['%s=%r' % (key, value)
10303 
      for key, value in self.__dict__.iteritems()]
10304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10305 
 
10306 
  def __eq__(self, other):
10307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10308 
 
10309 
  def __ne__(self, other):
10310 
    return not (self == other)
10311 
 
10312 
class addTag_result:
10313 
  """
10314 
  Attributes:
10315 
   - success
10316 
  """
10317 
 
10318 
  thrift_spec = (
10319 
    (0, TType.BOOL, 'success', None, None, ), # 0
10320 
  )
10321 
 
10322 
  def __init__(self, success=None,):
10323 
    self.success = success
10324 
 
10325 
  def read(self, iprot):
10326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10328 
      return
10329 
    iprot.readStructBegin()
10330 
    while True:
10331 
      (fname, ftype, fid) = iprot.readFieldBegin()
10332 
      if ftype == TType.STOP:
10333 
        break
10334 
      if fid == 0:
10335 
        if ftype == TType.BOOL:
10336 
          self.success = iprot.readBool();
10337 
        else:
10338 
          iprot.skip(ftype)
10339 
      else:
10340 
        iprot.skip(ftype)
10341 
      iprot.readFieldEnd()
10342 
    iprot.readStructEnd()
10343 
 
10344 
  def write(self, oprot):
10345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10347 
      return
10348 
    oprot.writeStructBegin('addTag_result')
10349 
    if self.success is not None:
10350 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10351 
      oprot.writeBool(self.success)
10352 
      oprot.writeFieldEnd()
10353 
    oprot.writeFieldStop()
10354 
    oprot.writeStructEnd()
10355 
 
10356 
  def validate(self):
10357 
    return
10358 
 
10359 
 
10360 
  def __repr__(self):
10361 
    L = ['%s=%r' % (key, value)
10362 
      for key, value in self.__dict__.iteritems()]
10363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10364 
 
10365 
  def __eq__(self, other):
10366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10367 
 
10368 
  def __ne__(self, other):
10369 
    return not (self == other)
10370 
 
10371 
class deleteEntityTag_args:
10372 
  """
10373 
  Attributes:
10374 
   - displayName
10375 
   - itemId
10376 
  """
10377 
 
10378 
  thrift_spec = (
10379 
    None, # 0
10380 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10381 
    (2, TType.I64, 'itemId', None, None, ), # 2
10382 
  )
10383 
 
10384 
  def __init__(self, displayName=None, itemId=None,):
10385 
    self.displayName = displayName
10386 
    self.itemId = itemId
10387 
 
10388 
  def read(self, iprot):
10389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10391 
      return
10392 
    iprot.readStructBegin()
10393 
    while True:
10394 
      (fname, ftype, fid) = iprot.readFieldBegin()
10395 
      if ftype == TType.STOP:
10396 
        break
10397 
      if fid == 1:
10398 
        if ftype == TType.STRING:
10399 
          self.displayName = iprot.readString();
10400 
        else:
10401 
          iprot.skip(ftype)
10402 
      elif fid == 2:
10403 
        if ftype == TType.I64:
10404 
          self.itemId = iprot.readI64();
10405 
        else:
10406 
          iprot.skip(ftype)
10407 
      else:
10408 
        iprot.skip(ftype)
10409 
      iprot.readFieldEnd()
10410 
    iprot.readStructEnd()
10411 
 
10412 
  def write(self, oprot):
10413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10415 
      return
10416 
    oprot.writeStructBegin('deleteEntityTag_args')
10417 
    if self.displayName is not None:
10418 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10419 
      oprot.writeString(self.displayName)
10420 
      oprot.writeFieldEnd()
10421 
    if self.itemId is not None:
10422 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10423 
      oprot.writeI64(self.itemId)
10424 
      oprot.writeFieldEnd()
10425 
    oprot.writeFieldStop()
10426 
    oprot.writeStructEnd()
10427 
 
10428 
  def validate(self):
10429 
    return
10430 
 
10431 
 
10432 
  def __repr__(self):
10433 
    L = ['%s=%r' % (key, value)
10434 
      for key, value in self.__dict__.iteritems()]
10435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10436 
 
10437 
  def __eq__(self, other):
10438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10439 
 
10440 
  def __ne__(self, other):
10441 
    return not (self == other)
10442 
 
10443 
class deleteEntityTag_result:
10444 
  """
10445 
  Attributes:
10446 
   - success
10447 
  """
10448 
 
10449 
  thrift_spec = (
10450 
    (0, TType.BOOL, 'success', None, None, ), # 0
10451 
  )
10452 
 
10453 
  def __init__(self, success=None,):
10454 
    self.success = success
10455 
 
10456 
  def read(self, iprot):
10457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10459 
      return
10460 
    iprot.readStructBegin()
10461 
    while True:
10462 
      (fname, ftype, fid) = iprot.readFieldBegin()
10463 
      if ftype == TType.STOP:
10464 
        break
10465 
      if fid == 0:
10466 
        if ftype == TType.BOOL:
10467 
          self.success = iprot.readBool();
10468 
        else:
10469 
          iprot.skip(ftype)
10470 
      else:
10471 
        iprot.skip(ftype)
10472 
      iprot.readFieldEnd()
10473 
    iprot.readStructEnd()
10474 
 
10475 
  def write(self, oprot):
10476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10478 
      return
10479 
    oprot.writeStructBegin('deleteEntityTag_result')
10480 
    if self.success is not None:
10481 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10482 
      oprot.writeBool(self.success)
10483 
      oprot.writeFieldEnd()
10484 
    oprot.writeFieldStop()
10485 
    oprot.writeStructEnd()
10486 
 
10487 
  def validate(self):
10488 
    return
10489 
 
10490 
 
10491 
  def __repr__(self):
10492 
    L = ['%s=%r' % (key, value)
10493 
      for key, value in self.__dict__.iteritems()]
10494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10495 
 
10496 
  def __eq__(self, other):
10497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10498 
 
10499 
  def __ne__(self, other):
10500 
    return not (self == other)
10501 
 
10502 
class deleteTag_args:
10503 
  """
10504 
  Attributes:
10505 
   - displayName
10506 
  """
10507 
 
10508 
  thrift_spec = (
10509 
    None, # 0
10510 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10511 
  )
10512 
 
10513 
  def __init__(self, displayName=None,):
10514 
    self.displayName = displayName
10515 
 
10516 
  def read(self, iprot):
10517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10519 
      return
10520 
    iprot.readStructBegin()
10521 
    while True:
10522 
      (fname, ftype, fid) = iprot.readFieldBegin()
10523 
      if ftype == TType.STOP:
10524 
        break
10525 
      if fid == 1:
10526 
        if ftype == TType.STRING:
10527 
          self.displayName = iprot.readString();
10528 
        else:
10529 
          iprot.skip(ftype)
10530 
      else:
10531 
        iprot.skip(ftype)
10532 
      iprot.readFieldEnd()
10533 
    iprot.readStructEnd()
10534 
 
10535 
  def write(self, oprot):
10536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10538 
      return
10539 
    oprot.writeStructBegin('deleteTag_args')
10540 
    if self.displayName is not None:
10541 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10542 
      oprot.writeString(self.displayName)
10543 
      oprot.writeFieldEnd()
10544 
    oprot.writeFieldStop()
10545 
    oprot.writeStructEnd()
10546 
 
10547 
  def validate(self):
10548 
    return
10549 
 
10550 
 
10551 
  def __repr__(self):
10552 
    L = ['%s=%r' % (key, value)
10553 
      for key, value in self.__dict__.iteritems()]
10554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10555 
 
10556 
  def __eq__(self, other):
10557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10558 
 
10559 
  def __ne__(self, other):
10560 
    return not (self == other)
10561 
 
10562 
class deleteTag_result:
10563 
  """
10564 
  Attributes:
10565 
   - success
10566 
  """
10567 
 
10568 
  thrift_spec = (
10569 
    (0, TType.BOOL, 'success', None, None, ), # 0
10570 
  )
10571 
 
10572 
  def __init__(self, success=None,):
10573 
    self.success = success
10574 
 
10575 
  def read(self, iprot):
10576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10578 
      return
10579 
    iprot.readStructBegin()
10580 
    while True:
10581 
      (fname, ftype, fid) = iprot.readFieldBegin()
10582 
      if ftype == TType.STOP:
10583 
        break
10584 
      if fid == 0:
10585 
        if ftype == TType.BOOL:
10586 
          self.success = iprot.readBool();
10587 
        else:
10588 
          iprot.skip(ftype)
10589 
      else:
10590 
        iprot.skip(ftype)
10591 
      iprot.readFieldEnd()
10592 
    iprot.readStructEnd()
10593 
 
10594 
  def write(self, oprot):
10595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10597 
      return
10598 
    oprot.writeStructBegin('deleteTag_result')
10599 
    if self.success is not None:
10600 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10601 
      oprot.writeBool(self.success)
10602 
      oprot.writeFieldEnd()
10603 
    oprot.writeFieldStop()
10604 
    oprot.writeStructEnd()
10605 
 
10606 
  def validate(self):
10607 
    return
10608 
 
10609 
 
10610 
  def __repr__(self):
10611 
    L = ['%s=%r' % (key, value)
10612 
      for key, value in self.__dict__.iteritems()]
10613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10614 
 
10615 
  def __eq__(self, other):
10616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10617 
 
10618 
  def __ne__(self, other):
10619 
    return not (self == other)
10620 
 
10621 
class getAllTags_args:
10622 
 
10623 
  thrift_spec = (
10624 
  )
10625 
 
10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
10635 
      else:
10636 
        iprot.skip(ftype)
10637 
      iprot.readFieldEnd()
10638 
    iprot.readStructEnd()
10639 
 
10640 
  def write(self, oprot):
10641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10643 
      return
10644 
    oprot.writeStructBegin('getAllTags_args')
10645 
    oprot.writeFieldStop()
10646 
    oprot.writeStructEnd()
10647 
 
10648 
  def validate(self):
10649 
    return
10650 
 
10651 
 
10652 
  def __repr__(self):
10653 
    L = ['%s=%r' % (key, value)
10654 
      for key, value in self.__dict__.iteritems()]
10655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10656 
 
10657 
  def __eq__(self, other):
10658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10659 
 
10660 
  def __ne__(self, other):
10661 
    return not (self == other)
10662 
 
10663 
class getAllTags_result:
10664 
  """
10665 
  Attributes:
10666 
   - success
10667 
  """
10668 
 
10669 
  thrift_spec = (
10670 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10671 
  )
10672 
 
10673 
  def __init__(self, success=None,):
10674 
    self.success = success
10675 
 
10676 
  def read(self, iprot):
10677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10679 
      return
10680 
    iprot.readStructBegin()
10681 
    while True:
10682 
      (fname, ftype, fid) = iprot.readFieldBegin()
10683 
      if ftype == TType.STOP:
10684 
        break
10685 
      if fid == 0:
10686 
        if ftype == TType.LIST:
10687 
          self.success = []
7438 amit.gupta 10688 
          (_etype154, _size151) = iprot.readListBegin()
10689 
          for _i155 in xrange(_size151):
10690 
            _elem156 = iprot.readString();
10691 
            self.success.append(_elem156)
6512 kshitij.so 10692 
          iprot.readListEnd()
10693 
        else:
10694 
          iprot.skip(ftype)
10695 
      else:
10696 
        iprot.skip(ftype)
10697 
      iprot.readFieldEnd()
10698 
    iprot.readStructEnd()
10699 
 
10700 
  def write(self, oprot):
10701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10703 
      return
10704 
    oprot.writeStructBegin('getAllTags_result')
10705 
    if self.success is not None:
10706 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10707 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10708 
      for iter157 in self.success:
10709 
        oprot.writeString(iter157)
6512 kshitij.so 10710 
      oprot.writeListEnd()
10711 
      oprot.writeFieldEnd()
10712 
    oprot.writeFieldStop()
10713 
    oprot.writeStructEnd()
10714 
 
10715 
  def validate(self):
10716 
    return
10717 
 
10718 
 
10719 
  def __repr__(self):
10720 
    L = ['%s=%r' % (key, value)
10721 
      for key, value in self.__dict__.iteritems()]
10722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10723 
 
10724 
  def __eq__(self, other):
10725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10726 
 
10727 
  def __ne__(self, other):
10728 
    return not (self == other)
10729 
 
10730 
class getAllEntitiesByTagName_args:
10731 
  """
10732 
  Attributes:
10733 
   - displayName
10734 
  """
10735 
 
10736 
  thrift_spec = (
10737 
    None, # 0
10738 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10739 
  )
10740 
 
10741 
  def __init__(self, displayName=None,):
10742 
    self.displayName = displayName
10743 
 
10744 
  def read(self, iprot):
10745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10747 
      return
10748 
    iprot.readStructBegin()
10749 
    while True:
10750 
      (fname, ftype, fid) = iprot.readFieldBegin()
10751 
      if ftype == TType.STOP:
10752 
        break
10753 
      if fid == 1:
10754 
        if ftype == TType.STRING:
10755 
          self.displayName = iprot.readString();
10756 
        else:
10757 
          iprot.skip(ftype)
10758 
      else:
10759 
        iprot.skip(ftype)
10760 
      iprot.readFieldEnd()
10761 
    iprot.readStructEnd()
10762 
 
10763 
  def write(self, oprot):
10764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10766 
      return
10767 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10768 
    if self.displayName is not None:
10769 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10770 
      oprot.writeString(self.displayName)
10771 
      oprot.writeFieldEnd()
10772 
    oprot.writeFieldStop()
10773 
    oprot.writeStructEnd()
10774 
 
10775 
  def validate(self):
10776 
    return
10777 
 
10778 
 
10779 
  def __repr__(self):
10780 
    L = ['%s=%r' % (key, value)
10781 
      for key, value in self.__dict__.iteritems()]
10782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10783 
 
10784 
  def __eq__(self, other):
10785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10786 
 
10787 
  def __ne__(self, other):
10788 
    return not (self == other)
10789 
 
10790 
class getAllEntitiesByTagName_result:
10791 
  """
10792 
  Attributes:
10793 
   - success
10794 
  """
10795 
 
10796 
  thrift_spec = (
10797 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10798 
  )
10799 
 
10800 
  def __init__(self, success=None,):
10801 
    self.success = success
10802 
 
10803 
  def read(self, iprot):
10804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10806 
      return
10807 
    iprot.readStructBegin()
10808 
    while True:
10809 
      (fname, ftype, fid) = iprot.readFieldBegin()
10810 
      if ftype == TType.STOP:
10811 
        break
10812 
      if fid == 0:
10813 
        if ftype == TType.LIST:
10814 
          self.success = []
7438 amit.gupta 10815 
          (_etype161, _size158) = iprot.readListBegin()
10816 
          for _i162 in xrange(_size158):
10817 
            _elem163 = iprot.readI64();
10818 
            self.success.append(_elem163)
6512 kshitij.so 10819 
          iprot.readListEnd()
10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      else:
10823 
        iprot.skip(ftype)
10824 
      iprot.readFieldEnd()
10825 
    iprot.readStructEnd()
10826 
 
10827 
  def write(self, oprot):
10828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10830 
      return
10831 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10832 
    if self.success is not None:
10833 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10834 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10835 
      for iter164 in self.success:
10836 
        oprot.writeI64(iter164)
6512 kshitij.so 10837 
      oprot.writeListEnd()
10838 
      oprot.writeFieldEnd()
10839 
    oprot.writeFieldStop()
10840 
    oprot.writeStructEnd()
10841 
 
10842 
  def validate(self):
10843 
    return
10844 
 
10845 
 
10846 
  def __repr__(self):
10847 
    L = ['%s=%r' % (key, value)
10848 
      for key, value in self.__dict__.iteritems()]
10849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10850 
 
10851 
  def __eq__(self, other):
10852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10853 
 
10854 
  def __ne__(self, other):
10855 
    return not (self == other)
10856 
 
6845 amit.gupta 10857 
class getAllEntityTags_args:
10858 
 
10859 
  thrift_spec = (
10860 
  )
10861 
 
10862 
  def read(self, iprot):
10863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10865 
      return
10866 
    iprot.readStructBegin()
10867 
    while True:
10868 
      (fname, ftype, fid) = iprot.readFieldBegin()
10869 
      if ftype == TType.STOP:
10870 
        break
10871 
      else:
10872 
        iprot.skip(ftype)
10873 
      iprot.readFieldEnd()
10874 
    iprot.readStructEnd()
10875 
 
10876 
  def write(self, oprot):
10877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10879 
      return
10880 
    oprot.writeStructBegin('getAllEntityTags_args')
10881 
    oprot.writeFieldStop()
10882 
    oprot.writeStructEnd()
10883 
 
10884 
  def validate(self):
10885 
    return
10886 
 
10887 
 
10888 
  def __repr__(self):
10889 
    L = ['%s=%r' % (key, value)
10890 
      for key, value in self.__dict__.iteritems()]
10891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10892 
 
10893 
  def __eq__(self, other):
10894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10895 
 
10896 
  def __ne__(self, other):
10897 
    return not (self == other)
10898 
 
10899 
class getAllEntityTags_result:
10900 
  """
10901 
  Attributes:
10902 
   - success
10903 
  """
10904 
 
10905 
  thrift_spec = (
10906 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10907 
  )
10908 
 
10909 
  def __init__(self, success=None,):
10910 
    self.success = success
10911 
 
10912 
  def read(self, iprot):
10913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10915 
      return
10916 
    iprot.readStructBegin()
10917 
    while True:
10918 
      (fname, ftype, fid) = iprot.readFieldBegin()
10919 
      if ftype == TType.STOP:
10920 
        break
10921 
      if fid == 0:
10922 
        if ftype == TType.MAP:
10923 
          self.success = {}
7438 amit.gupta 10924 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10925 
          for _i169 in xrange(_size165):
10926 
            _key170 = iprot.readI64();
10927 
            _val171 = []
10928 
            (_etype175, _size172) = iprot.readListBegin()
10929 
            for _i176 in xrange(_size172):
10930 
              _elem177 = iprot.readString();
10931 
              _val171.append(_elem177)
6845 amit.gupta 10932 
            iprot.readListEnd()
7438 amit.gupta 10933 
            self.success[_key170] = _val171
6845 amit.gupta 10934 
          iprot.readMapEnd()
10935 
        else:
10936 
          iprot.skip(ftype)
10937 
      else:
10938 
        iprot.skip(ftype)
10939 
      iprot.readFieldEnd()
10940 
    iprot.readStructEnd()
10941 
 
10942 
  def write(self, oprot):
10943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10945 
      return
10946 
    oprot.writeStructBegin('getAllEntityTags_result')
10947 
    if self.success is not None:
10948 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10949 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10950 
      for kiter178,viter179 in self.success.items():
10951 
        oprot.writeI64(kiter178)
10952 
        oprot.writeListBegin(TType.STRING, len(viter179))
10953 
        for iter180 in viter179:
10954 
          oprot.writeString(iter180)
6845 amit.gupta 10955 
        oprot.writeListEnd()
10956 
      oprot.writeMapEnd()
10957 
      oprot.writeFieldEnd()
10958 
    oprot.writeFieldStop()
10959 
    oprot.writeStructEnd()
10960 
 
10961 
  def validate(self):
10962 
    return
10963 
 
10964 
 
10965 
  def __repr__(self):
10966 
    L = ['%s=%r' % (key, value)
10967 
      for key, value in self.__dict__.iteritems()]
10968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10969 
 
10970 
  def __eq__(self, other):
10971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10972 
 
10973 
  def __ne__(self, other):
10974 
    return not (self == other)
10975 
 
6850 kshitij.so 10976 
class addBanner_args:
10977 
  """
10978 
  Attributes:
10979 
   - bannerName
10980 
   - imageName
10981 
   - link
10982 
   - priority
10983 
   - isActive
10984 
   - hasMap
10985 
  """
10986 
 
10987 
  thrift_spec = (
10988 
    None, # 0
10989 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10990 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10991 
    (3, TType.STRING, 'link', None, None, ), # 3
10992 
    (4, TType.I64, 'priority', None, None, ), # 4
10993 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10994 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10995 
  )
10996 
 
10997 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10998 
    self.bannerName = bannerName
10999 
    self.imageName = imageName
11000 
    self.link = link
11001 
    self.priority = priority
11002 
    self.isActive = isActive
11003 
    self.hasMap = hasMap
11004 
 
11005 
  def read(self, iprot):
11006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11008 
      return
11009 
    iprot.readStructBegin()
11010 
    while True:
11011 
      (fname, ftype, fid) = iprot.readFieldBegin()
11012 
      if ftype == TType.STOP:
11013 
        break
11014 
      if fid == 1:
11015 
        if ftype == TType.STRING:
11016 
          self.bannerName = iprot.readString();
11017 
        else:
11018 
          iprot.skip(ftype)
11019 
      elif fid == 2:
11020 
        if ftype == TType.STRING:
11021 
          self.imageName = iprot.readString();
11022 
        else:
11023 
          iprot.skip(ftype)
11024 
      elif fid == 3:
11025 
        if ftype == TType.STRING:
11026 
          self.link = iprot.readString();
11027 
        else:
11028 
          iprot.skip(ftype)
11029 
      elif fid == 4:
11030 
        if ftype == TType.I64:
11031 
          self.priority = iprot.readI64();
11032 
        else:
11033 
          iprot.skip(ftype)
11034 
      elif fid == 5:
11035 
        if ftype == TType.BOOL:
11036 
          self.isActive = iprot.readBool();
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      elif fid == 6:
11040 
        if ftype == TType.BOOL:
11041 
          self.hasMap = iprot.readBool();
11042 
        else:
11043 
          iprot.skip(ftype)
11044 
      else:
11045 
        iprot.skip(ftype)
11046 
      iprot.readFieldEnd()
11047 
    iprot.readStructEnd()
11048 
 
11049 
  def write(self, oprot):
11050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11052 
      return
11053 
    oprot.writeStructBegin('addBanner_args')
11054 
    if self.bannerName is not None:
11055 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11056 
      oprot.writeString(self.bannerName)
11057 
      oprot.writeFieldEnd()
11058 
    if self.imageName is not None:
11059 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
11060 
      oprot.writeString(self.imageName)
11061 
      oprot.writeFieldEnd()
11062 
    if self.link is not None:
11063 
      oprot.writeFieldBegin('link', TType.STRING, 3)
11064 
      oprot.writeString(self.link)
11065 
      oprot.writeFieldEnd()
11066 
    if self.priority is not None:
11067 
      oprot.writeFieldBegin('priority', TType.I64, 4)
11068 
      oprot.writeI64(self.priority)
11069 
      oprot.writeFieldEnd()
11070 
    if self.isActive is not None:
11071 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
11072 
      oprot.writeBool(self.isActive)
11073 
      oprot.writeFieldEnd()
11074 
    if self.hasMap is not None:
11075 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
11076 
      oprot.writeBool(self.hasMap)
11077 
      oprot.writeFieldEnd()
11078 
    oprot.writeFieldStop()
11079 
    oprot.writeStructEnd()
11080 
 
11081 
  def validate(self):
11082 
    return
11083 
 
11084 
 
11085 
  def __repr__(self):
11086 
    L = ['%s=%r' % (key, value)
11087 
      for key, value in self.__dict__.iteritems()]
11088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11089 
 
11090 
  def __eq__(self, other):
11091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11092 
 
11093 
  def __ne__(self, other):
11094 
    return not (self == other)
11095 
 
11096 
class addBanner_result:
11097 
  """
11098 
  Attributes:
11099 
   - success
11100 
  """
11101 
 
11102 
  thrift_spec = (
11103 
    (0, TType.BOOL, 'success', None, None, ), # 0
11104 
  )
11105 
 
11106 
  def __init__(self, success=None,):
11107 
    self.success = success
11108 
 
11109 
  def read(self, iprot):
11110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11112 
      return
11113 
    iprot.readStructBegin()
11114 
    while True:
11115 
      (fname, ftype, fid) = iprot.readFieldBegin()
11116 
      if ftype == TType.STOP:
11117 
        break
11118 
      if fid == 0:
11119 
        if ftype == TType.BOOL:
11120 
          self.success = iprot.readBool();
11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
11132 
    oprot.writeStructBegin('addBanner_result')
11133 
    if self.success is not None:
11134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11135 
      oprot.writeBool(self.success)
11136 
      oprot.writeFieldEnd()
11137 
    oprot.writeFieldStop()
11138 
    oprot.writeStructEnd()
11139 
 
11140 
  def validate(self):
11141 
    return
11142 
 
11143 
 
11144 
  def __repr__(self):
11145 
    L = ['%s=%r' % (key, value)
11146 
      for key, value in self.__dict__.iteritems()]
11147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11148 
 
11149 
  def __eq__(self, other):
11150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11151 
 
11152 
  def __ne__(self, other):
11153 
    return not (self == other)
11154 
 
11155 
class getAllBanners_args:
11156 
 
11157 
  thrift_spec = (
11158 
  )
11159 
 
11160 
  def read(self, iprot):
11161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11163 
      return
11164 
    iprot.readStructBegin()
11165 
    while True:
11166 
      (fname, ftype, fid) = iprot.readFieldBegin()
11167 
      if ftype == TType.STOP:
11168 
        break
11169 
      else:
11170 
        iprot.skip(ftype)
11171 
      iprot.readFieldEnd()
11172 
    iprot.readStructEnd()
11173 
 
11174 
  def write(self, oprot):
11175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11177 
      return
11178 
    oprot.writeStructBegin('getAllBanners_args')
11179 
    oprot.writeFieldStop()
11180 
    oprot.writeStructEnd()
11181 
 
11182 
  def validate(self):
11183 
    return
11184 
 
11185 
 
11186 
  def __repr__(self):
11187 
    L = ['%s=%r' % (key, value)
11188 
      for key, value in self.__dict__.iteritems()]
11189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11190 
 
11191 
  def __eq__(self, other):
11192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11193 
 
11194 
  def __ne__(self, other):
11195 
    return not (self == other)
11196 
 
11197 
class getAllBanners_result:
11198 
  """
11199 
  Attributes:
11200 
   - success
11201 
  """
11202 
 
11203 
  thrift_spec = (
11204 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11205 
  )
11206 
 
11207 
  def __init__(self, success=None,):
11208 
    self.success = success
11209 
 
11210 
  def read(self, iprot):
11211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11213 
      return
11214 
    iprot.readStructBegin()
11215 
    while True:
11216 
      (fname, ftype, fid) = iprot.readFieldBegin()
11217 
      if ftype == TType.STOP:
11218 
        break
11219 
      if fid == 0:
11220 
        if ftype == TType.LIST:
11221 
          self.success = []
7438 amit.gupta 11222 
          (_etype184, _size181) = iprot.readListBegin()
11223 
          for _i185 in xrange(_size181):
11224 
            _elem186 = iprot.readString();
11225 
            self.success.append(_elem186)
6850 kshitij.so 11226 
          iprot.readListEnd()
11227 
        else:
11228 
          iprot.skip(ftype)
11229 
      else:
11230 
        iprot.skip(ftype)
11231 
      iprot.readFieldEnd()
11232 
    iprot.readStructEnd()
11233 
 
11234 
  def write(self, oprot):
11235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11237 
      return
11238 
    oprot.writeStructBegin('getAllBanners_result')
11239 
    if self.success is not None:
11240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11241 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11242 
      for iter187 in self.success:
11243 
        oprot.writeString(iter187)
6850 kshitij.so 11244 
      oprot.writeListEnd()
11245 
      oprot.writeFieldEnd()
11246 
    oprot.writeFieldStop()
11247 
    oprot.writeStructEnd()
11248 
 
11249 
  def validate(self):
11250 
    return
11251 
 
11252 
 
11253 
  def __repr__(self):
11254 
    L = ['%s=%r' % (key, value)
11255 
      for key, value in self.__dict__.iteritems()]
11256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11257 
 
11258 
  def __eq__(self, other):
11259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11260 
 
11261 
  def __ne__(self, other):
11262 
    return not (self == other)
11263 
 
11264 
class deleteBanner_args:
11265 
  """
11266 
  Attributes:
11267 
   - bannerName
11268 
  """
11269 
 
11270 
  thrift_spec = (
11271 
    None, # 0
11272 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11273 
  )
11274 
 
11275 
  def __init__(self, bannerName=None,):
11276 
    self.bannerName = bannerName
11277 
 
11278 
  def read(self, iprot):
11279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11281 
      return
11282 
    iprot.readStructBegin()
11283 
    while True:
11284 
      (fname, ftype, fid) = iprot.readFieldBegin()
11285 
      if ftype == TType.STOP:
11286 
        break
11287 
      if fid == 1:
11288 
        if ftype == TType.STRING:
11289 
          self.bannerName = iprot.readString();
11290 
        else:
11291 
          iprot.skip(ftype)
11292 
      else:
11293 
        iprot.skip(ftype)
11294 
      iprot.readFieldEnd()
11295 
    iprot.readStructEnd()
11296 
 
11297 
  def write(self, oprot):
11298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11300 
      return
11301 
    oprot.writeStructBegin('deleteBanner_args')
11302 
    if self.bannerName is not None:
11303 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11304 
      oprot.writeString(self.bannerName)
11305 
      oprot.writeFieldEnd()
11306 
    oprot.writeFieldStop()
11307 
    oprot.writeStructEnd()
11308 
 
11309 
  def validate(self):
11310 
    return
11311 
 
11312 
 
11313 
  def __repr__(self):
11314 
    L = ['%s=%r' % (key, value)
11315 
      for key, value in self.__dict__.iteritems()]
11316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11317 
 
11318 
  def __eq__(self, other):
11319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11320 
 
11321 
  def __ne__(self, other):
11322 
    return not (self == other)
11323 
 
11324 
class deleteBanner_result:
11325 
  """
11326 
  Attributes:
11327 
   - success
11328 
  """
11329 
 
11330 
  thrift_spec = (
11331 
    (0, TType.BOOL, 'success', None, None, ), # 0
11332 
  )
11333 
 
11334 
  def __init__(self, success=None,):
11335 
    self.success = success
11336 
 
11337 
  def read(self, iprot):
11338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11340 
      return
11341 
    iprot.readStructBegin()
11342 
    while True:
11343 
      (fname, ftype, fid) = iprot.readFieldBegin()
11344 
      if ftype == TType.STOP:
11345 
        break
11346 
      if fid == 0:
11347 
        if ftype == TType.BOOL:
11348 
          self.success = iprot.readBool();
11349 
        else:
11350 
          iprot.skip(ftype)
11351 
      else:
11352 
        iprot.skip(ftype)
11353 
      iprot.readFieldEnd()
11354 
    iprot.readStructEnd()
11355 
 
11356 
  def write(self, oprot):
11357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11359 
      return
11360 
    oprot.writeStructBegin('deleteBanner_result')
11361 
    if self.success is not None:
11362 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11363 
      oprot.writeBool(self.success)
11364 
      oprot.writeFieldEnd()
11365 
    oprot.writeFieldStop()
11366 
    oprot.writeStructEnd()
11367 
 
11368 
  def validate(self):
11369 
    return
11370 
 
11371 
 
11372 
  def __repr__(self):
11373 
    L = ['%s=%r' % (key, value)
11374 
      for key, value in self.__dict__.iteritems()]
11375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11376 
 
11377 
  def __eq__(self, other):
11378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11379 
 
11380 
  def __ne__(self, other):
11381 
    return not (self == other)
11382 
 
11383 
class getBannerDetails_args:
11384 
  """
11385 
  Attributes:
11386 
   - bannerName
11387 
  """
11388 
 
11389 
  thrift_spec = (
11390 
    None, # 0
11391 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11392 
  )
11393 
 
11394 
  def __init__(self, bannerName=None,):
11395 
    self.bannerName = bannerName
11396 
 
11397 
  def read(self, iprot):
11398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11400 
      return
11401 
    iprot.readStructBegin()
11402 
    while True:
11403 
      (fname, ftype, fid) = iprot.readFieldBegin()
11404 
      if ftype == TType.STOP:
11405 
        break
11406 
      if fid == 1:
11407 
        if ftype == TType.STRING:
11408 
          self.bannerName = iprot.readString();
11409 
        else:
11410 
          iprot.skip(ftype)
11411 
      else:
11412 
        iprot.skip(ftype)
11413 
      iprot.readFieldEnd()
11414 
    iprot.readStructEnd()
11415 
 
11416 
  def write(self, oprot):
11417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11419 
      return
11420 
    oprot.writeStructBegin('getBannerDetails_args')
11421 
    if self.bannerName is not None:
11422 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11423 
      oprot.writeString(self.bannerName)
11424 
      oprot.writeFieldEnd()
11425 
    oprot.writeFieldStop()
11426 
    oprot.writeStructEnd()
11427 
 
11428 
  def validate(self):
11429 
    return
11430 
 
11431 
 
11432 
  def __repr__(self):
11433 
    L = ['%s=%r' % (key, value)
11434 
      for key, value in self.__dict__.iteritems()]
11435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11436 
 
11437 
  def __eq__(self, other):
11438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11439 
 
11440 
  def __ne__(self, other):
11441 
    return not (self == other)
11442 
 
11443 
class getBannerDetails_result:
11444 
  """
11445 
  Attributes:
11446 
   - success
11447 
  """
11448 
 
11449 
  thrift_spec = (
11450 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11451 
  )
11452 
 
11453 
  def __init__(self, success=None,):
11454 
    self.success = success
11455 
 
11456 
  def read(self, iprot):
11457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11459 
      return
11460 
    iprot.readStructBegin()
11461 
    while True:
11462 
      (fname, ftype, fid) = iprot.readFieldBegin()
11463 
      if ftype == TType.STOP:
11464 
        break
11465 
      if fid == 0:
11466 
        if ftype == TType.STRUCT:
11467 
          self.success = Banner()
11468 
          self.success.read(iprot)
11469 
        else:
11470 
          iprot.skip(ftype)
11471 
      else:
11472 
        iprot.skip(ftype)
11473 
      iprot.readFieldEnd()
11474 
    iprot.readStructEnd()
11475 
 
11476 
  def write(self, oprot):
11477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11479 
      return
11480 
    oprot.writeStructBegin('getBannerDetails_result')
11481 
    if self.success is not None:
11482 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11483 
      self.success.write(oprot)
11484 
      oprot.writeFieldEnd()
11485 
    oprot.writeFieldStop()
11486 
    oprot.writeStructEnd()
11487 
 
11488 
  def validate(self):
11489 
    return
11490 
 
11491 
 
11492 
  def __repr__(self):
11493 
    L = ['%s=%r' % (key, value)
11494 
      for key, value in self.__dict__.iteritems()]
11495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11496 
 
11497 
  def __eq__(self, other):
11498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11499 
 
11500 
  def __ne__(self, other):
11501 
    return not (self == other)
11502 
 
11503 
class getActiveBanners_args:
11504 
 
11505 
  thrift_spec = (
11506 
  )
11507 
 
11508 
  def read(self, iprot):
11509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11511 
      return
11512 
    iprot.readStructBegin()
11513 
    while True:
11514 
      (fname, ftype, fid) = iprot.readFieldBegin()
11515 
      if ftype == TType.STOP:
11516 
        break
11517 
      else:
11518 
        iprot.skip(ftype)
11519 
      iprot.readFieldEnd()
11520 
    iprot.readStructEnd()
11521 
 
11522 
  def write(self, oprot):
11523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11525 
      return
11526 
    oprot.writeStructBegin('getActiveBanners_args')
11527 
    oprot.writeFieldStop()
11528 
    oprot.writeStructEnd()
11529 
 
11530 
  def validate(self):
11531 
    return
11532 
 
11533 
 
11534 
  def __repr__(self):
11535 
    L = ['%s=%r' % (key, value)
11536 
      for key, value in self.__dict__.iteritems()]
11537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11538 
 
11539 
  def __eq__(self, other):
11540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11541 
 
11542 
  def __ne__(self, other):
11543 
    return not (self == other)
11544 
 
11545 
class getActiveBanners_result:
11546 
  """
11547 
  Attributes:
11548 
   - success
11549 
  """
11550 
 
11551 
  thrift_spec = (
11552 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11553 
  )
11554 
 
11555 
  def __init__(self, success=None,):
11556 
    self.success = success
11557 
 
11558 
  def read(self, iprot):
11559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11561 
      return
11562 
    iprot.readStructBegin()
11563 
    while True:
11564 
      (fname, ftype, fid) = iprot.readFieldBegin()
11565 
      if ftype == TType.STOP:
11566 
        break
11567 
      if fid == 0:
11568 
        if ftype == TType.LIST:
11569 
          self.success = []
7438 amit.gupta 11570 
          (_etype191, _size188) = iprot.readListBegin()
11571 
          for _i192 in xrange(_size188):
11572 
            _elem193 = Banner()
11573 
            _elem193.read(iprot)
11574 
            self.success.append(_elem193)
6850 kshitij.so 11575 
          iprot.readListEnd()
11576 
        else:
11577 
          iprot.skip(ftype)
11578 
      else:
11579 
        iprot.skip(ftype)
11580 
      iprot.readFieldEnd()
11581 
    iprot.readStructEnd()
11582 
 
11583 
  def write(self, oprot):
11584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11586 
      return
11587 
    oprot.writeStructBegin('getActiveBanners_result')
11588 
    if self.success is not None:
11589 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11590 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11591 
      for iter194 in self.success:
11592 
        iter194.write(oprot)
6850 kshitij.so 11593 
      oprot.writeListEnd()
11594 
      oprot.writeFieldEnd()
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
11612 
 
6849 kshitij.so 11613 
class addBannerMap_args:
11614 
  """
11615 
  Attributes:
11616 
   - bannerName
11617 
   - mapLink
11618 
   - coordinates
11619 
  """
11620 
 
11621 
  thrift_spec = (
11622 
    None, # 0
11623 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11624 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11625 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11626 
  )
11627 
 
11628 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11629 
    self.bannerName = bannerName
11630 
    self.mapLink = mapLink
11631 
    self.coordinates = coordinates
11632 
 
11633 
  def read(self, iprot):
11634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11636 
      return
11637 
    iprot.readStructBegin()
11638 
    while True:
11639 
      (fname, ftype, fid) = iprot.readFieldBegin()
11640 
      if ftype == TType.STOP:
11641 
        break
11642 
      if fid == 1:
11643 
        if ftype == TType.STRING:
11644 
          self.bannerName = iprot.readString();
11645 
        else:
11646 
          iprot.skip(ftype)
11647 
      elif fid == 2:
11648 
        if ftype == TType.STRING:
11649 
          self.mapLink = iprot.readString();
11650 
        else:
11651 
          iprot.skip(ftype)
11652 
      elif fid == 3:
11653 
        if ftype == TType.STRING:
11654 
          self.coordinates = iprot.readString();
11655 
        else:
11656 
          iprot.skip(ftype)
11657 
      else:
11658 
        iprot.skip(ftype)
11659 
      iprot.readFieldEnd()
11660 
    iprot.readStructEnd()
11661 
 
11662 
  def write(self, oprot):
11663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11665 
      return
11666 
    oprot.writeStructBegin('addBannerMap_args')
11667 
    if self.bannerName is not None:
11668 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11669 
      oprot.writeString(self.bannerName)
11670 
      oprot.writeFieldEnd()
11671 
    if self.mapLink is not None:
11672 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11673 
      oprot.writeString(self.mapLink)
11674 
      oprot.writeFieldEnd()
11675 
    if self.coordinates is not None:
11676 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11677 
      oprot.writeString(self.coordinates)
11678 
      oprot.writeFieldEnd()
11679 
    oprot.writeFieldStop()
11680 
    oprot.writeStructEnd()
11681 
 
11682 
  def validate(self):
11683 
    return
11684 
 
11685 
 
11686 
  def __repr__(self):
11687 
    L = ['%s=%r' % (key, value)
11688 
      for key, value in self.__dict__.iteritems()]
11689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11690 
 
11691 
  def __eq__(self, other):
11692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11693 
 
11694 
  def __ne__(self, other):
11695 
    return not (self == other)
11696 
 
11697 
class addBannerMap_result:
11698 
  """
11699 
  Attributes:
11700 
   - success
11701 
  """
11702 
 
11703 
  thrift_spec = (
11704 
    (0, TType.BOOL, 'success', None, None, ), # 0
11705 
  )
11706 
 
11707 
  def __init__(self, success=None,):
11708 
    self.success = success
11709 
 
11710 
  def read(self, iprot):
11711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11713 
      return
11714 
    iprot.readStructBegin()
11715 
    while True:
11716 
      (fname, ftype, fid) = iprot.readFieldBegin()
11717 
      if ftype == TType.STOP:
11718 
        break
11719 
      if fid == 0:
11720 
        if ftype == TType.BOOL:
11721 
          self.success = iprot.readBool();
11722 
        else:
11723 
          iprot.skip(ftype)
11724 
      else:
11725 
        iprot.skip(ftype)
11726 
      iprot.readFieldEnd()
11727 
    iprot.readStructEnd()
11728 
 
11729 
  def write(self, oprot):
11730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11732 
      return
11733 
    oprot.writeStructBegin('addBannerMap_result')
11734 
    if self.success is not None:
11735 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11736 
      oprot.writeBool(self.success)
11737 
      oprot.writeFieldEnd()
11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
11756 
class deleteBannerMap_args:
11757 
  """
11758 
  Attributes:
11759 
   - bannerName
11760 
  """
11761 
 
11762 
  thrift_spec = (
11763 
    None, # 0
11764 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11765 
  )
11766 
 
11767 
  def __init__(self, bannerName=None,):
11768 
    self.bannerName = bannerName
11769 
 
11770 
  def read(self, iprot):
11771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11773 
      return
11774 
    iprot.readStructBegin()
11775 
    while True:
11776 
      (fname, ftype, fid) = iprot.readFieldBegin()
11777 
      if ftype == TType.STOP:
11778 
        break
11779 
      if fid == 1:
11780 
        if ftype == TType.STRING:
11781 
          self.bannerName = iprot.readString();
11782 
        else:
11783 
          iprot.skip(ftype)
11784 
      else:
11785 
        iprot.skip(ftype)
11786 
      iprot.readFieldEnd()
11787 
    iprot.readStructEnd()
11788 
 
11789 
  def write(self, oprot):
11790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11792 
      return
11793 
    oprot.writeStructBegin('deleteBannerMap_args')
11794 
    if self.bannerName is not None:
11795 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11796 
      oprot.writeString(self.bannerName)
11797 
      oprot.writeFieldEnd()
11798 
    oprot.writeFieldStop()
11799 
    oprot.writeStructEnd()
11800 
 
11801 
  def validate(self):
11802 
    return
11803 
 
11804 
 
11805 
  def __repr__(self):
11806 
    L = ['%s=%r' % (key, value)
11807 
      for key, value in self.__dict__.iteritems()]
11808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11809 
 
11810 
  def __eq__(self, other):
11811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11812 
 
11813 
  def __ne__(self, other):
11814 
    return not (self == other)
11815 
 
11816 
class deleteBannerMap_result:
11817 
  """
11818 
  Attributes:
11819 
   - success
11820 
  """
11821 
 
11822 
  thrift_spec = (
11823 
    (0, TType.BOOL, 'success', None, None, ), # 0
11824 
  )
11825 
 
11826 
  def __init__(self, success=None,):
11827 
    self.success = success
11828 
 
11829 
  def read(self, iprot):
11830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11832 
      return
11833 
    iprot.readStructBegin()
11834 
    while True:
11835 
      (fname, ftype, fid) = iprot.readFieldBegin()
11836 
      if ftype == TType.STOP:
11837 
        break
11838 
      if fid == 0:
11839 
        if ftype == TType.BOOL:
11840 
          self.success = iprot.readBool();
11841 
        else:
11842 
          iprot.skip(ftype)
11843 
      else:
11844 
        iprot.skip(ftype)
11845 
      iprot.readFieldEnd()
11846 
    iprot.readStructEnd()
11847 
 
11848 
  def write(self, oprot):
11849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11851 
      return
11852 
    oprot.writeStructBegin('deleteBannerMap_result')
11853 
    if self.success is not None:
11854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11855 
      oprot.writeBool(self.success)
11856 
      oprot.writeFieldEnd()
11857 
    oprot.writeFieldStop()
11858 
    oprot.writeStructEnd()
11859 
 
11860 
  def validate(self):
11861 
    return
11862 
 
11863 
 
11864 
  def __repr__(self):
11865 
    L = ['%s=%r' % (key, value)
11866 
      for key, value in self.__dict__.iteritems()]
11867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11868 
 
11869 
  def __eq__(self, other):
11870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11871 
 
11872 
  def __ne__(self, other):
11873 
    return not (self == other)
11874 
 
11875 
class getBannerMapDetails_args:
11876 
  """
11877 
  Attributes:
11878 
   - bannerName
11879 
  """
11880 
 
11881 
  thrift_spec = (
11882 
    None, # 0
11883 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11884 
  )
11885 
 
11886 
  def __init__(self, bannerName=None,):
11887 
    self.bannerName = bannerName
11888 
 
11889 
  def read(self, iprot):
11890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11892 
      return
11893 
    iprot.readStructBegin()
11894 
    while True:
11895 
      (fname, ftype, fid) = iprot.readFieldBegin()
11896 
      if ftype == TType.STOP:
11897 
        break
11898 
      if fid == 1:
11899 
        if ftype == TType.STRING:
11900 
          self.bannerName = iprot.readString();
11901 
        else:
11902 
          iprot.skip(ftype)
11903 
      else:
11904 
        iprot.skip(ftype)
11905 
      iprot.readFieldEnd()
11906 
    iprot.readStructEnd()
11907 
 
11908 
  def write(self, oprot):
11909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11911 
      return
11912 
    oprot.writeStructBegin('getBannerMapDetails_args')
11913 
    if self.bannerName is not None:
11914 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11915 
      oprot.writeString(self.bannerName)
11916 
      oprot.writeFieldEnd()
11917 
    oprot.writeFieldStop()
11918 
    oprot.writeStructEnd()
11919 
 
11920 
  def validate(self):
11921 
    return
11922 
 
11923 
 
11924 
  def __repr__(self):
11925 
    L = ['%s=%r' % (key, value)
11926 
      for key, value in self.__dict__.iteritems()]
11927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11928 
 
11929 
  def __eq__(self, other):
11930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11931 
 
11932 
  def __ne__(self, other):
11933 
    return not (self == other)
11934 
 
11935 
class getBannerMapDetails_result:
11936 
  """
11937 
  Attributes:
11938 
   - success
11939 
  """
11940 
 
11941 
  thrift_spec = (
11942 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11943 
  )
11944 
 
11945 
  def __init__(self, success=None,):
11946 
    self.success = success
11947 
 
11948 
  def read(self, iprot):
11949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11951 
      return
11952 
    iprot.readStructBegin()
11953 
    while True:
11954 
      (fname, ftype, fid) = iprot.readFieldBegin()
11955 
      if ftype == TType.STOP:
11956 
        break
11957 
      if fid == 0:
11958 
        if ftype == TType.LIST:
11959 
          self.success = []
7438 amit.gupta 11960 
          (_etype198, _size195) = iprot.readListBegin()
11961 
          for _i199 in xrange(_size195):
11962 
            _elem200 = BannerMap()
11963 
            _elem200.read(iprot)
11964 
            self.success.append(_elem200)
6849 kshitij.so 11965 
          iprot.readListEnd()
11966 
        else:
11967 
          iprot.skip(ftype)
11968 
      else:
11969 
        iprot.skip(ftype)
11970 
      iprot.readFieldEnd()
11971 
    iprot.readStructEnd()
11972 
 
11973 
  def write(self, oprot):
11974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11976 
      return
11977 
    oprot.writeStructBegin('getBannerMapDetails_result')
11978 
    if self.success is not None:
11979 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11980 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11981 
      for iter201 in self.success:
11982 
        iter201.write(oprot)
6849 kshitij.so 11983 
      oprot.writeListEnd()
11984 
      oprot.writeFieldEnd()
11985 
    oprot.writeFieldStop()
11986 
    oprot.writeStructEnd()
11987 
 
11988 
  def validate(self):
11989 
    return
11990 
 
11991 
 
11992 
  def __repr__(self):
11993 
    L = ['%s=%r' % (key, value)
11994 
      for key, value in self.__dict__.iteritems()]
11995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11996 
 
11997 
  def __eq__(self, other):
11998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11999 
 
12000 
  def __ne__(self, other):
12001 
    return not (self == other)
12002 
 
5944 mandeep.dh 12003 
class deleteSimilarItem_args:
12004 
  """
12005 
  Attributes:
12006 
   - itemId
12007 
   - catalogItemId
12008 
  """
12009 
 
12010 
  thrift_spec = (
12011 
    None, # 0
12012 
    (1, TType.I64, 'itemId', None, None, ), # 1
12013 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12014 
  )
12015 
 
12016 
  def __init__(self, itemId=None, catalogItemId=None,):
12017 
    self.itemId = itemId
12018 
    self.catalogItemId = catalogItemId
12019 
 
12020 
  def read(self, iprot):
12021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12023 
      return
12024 
    iprot.readStructBegin()
12025 
    while True:
12026 
      (fname, ftype, fid) = iprot.readFieldBegin()
12027 
      if ftype == TType.STOP:
12028 
        break
12029 
      if fid == 1:
12030 
        if ftype == TType.I64:
12031 
          self.itemId = iprot.readI64();
12032 
        else:
12033 
          iprot.skip(ftype)
12034 
      elif fid == 2:
12035 
        if ftype == TType.I64:
12036 
          self.catalogItemId = iprot.readI64();
12037 
        else:
12038 
          iprot.skip(ftype)
12039 
      else:
12040 
        iprot.skip(ftype)
12041 
      iprot.readFieldEnd()
12042 
    iprot.readStructEnd()
12043 
 
12044 
  def write(self, oprot):
12045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12047 
      return
12048 
    oprot.writeStructBegin('deleteSimilarItem_args')
12049 
    if self.itemId is not None:
12050 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12051 
      oprot.writeI64(self.itemId)
12052 
      oprot.writeFieldEnd()
12053 
    if self.catalogItemId is not None:
12054 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12055 
      oprot.writeI64(self.catalogItemId)
12056 
      oprot.writeFieldEnd()
12057 
    oprot.writeFieldStop()
12058 
    oprot.writeStructEnd()
12059 
 
12060 
  def validate(self):
12061 
    return
12062 
 
12063 
 
12064 
  def __repr__(self):
12065 
    L = ['%s=%r' % (key, value)
12066 
      for key, value in self.__dict__.iteritems()]
12067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12068 
 
12069 
  def __eq__(self, other):
12070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12071 
 
12072 
  def __ne__(self, other):
12073 
    return not (self == other)
12074 
 
12075 
class deleteSimilarItem_result:
12076 
  """
12077 
  Attributes:
12078 
   - success
12079 
   - cex
12080 
  """
12081 
 
12082 
  thrift_spec = (
12083 
    (0, TType.BOOL, 'success', None, None, ), # 0
12084 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12085 
  )
12086 
 
12087 
  def __init__(self, success=None, cex=None,):
12088 
    self.success = success
12089 
    self.cex = cex
12090 
 
12091 
  def read(self, iprot):
12092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12094 
      return
12095 
    iprot.readStructBegin()
12096 
    while True:
12097 
      (fname, ftype, fid) = iprot.readFieldBegin()
12098 
      if ftype == TType.STOP:
12099 
        break
12100 
      if fid == 0:
12101 
        if ftype == TType.BOOL:
12102 
          self.success = iprot.readBool();
12103 
        else:
12104 
          iprot.skip(ftype)
12105 
      elif fid == 1:
12106 
        if ftype == TType.STRUCT:
12107 
          self.cex = CatalogServiceException()
12108 
          self.cex.read(iprot)
12109 
        else:
12110 
          iprot.skip(ftype)
12111 
      else:
12112 
        iprot.skip(ftype)
12113 
      iprot.readFieldEnd()
12114 
    iprot.readStructEnd()
12115 
 
12116 
  def write(self, oprot):
12117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12119 
      return
12120 
    oprot.writeStructBegin('deleteSimilarItem_result')
12121 
    if self.success is not None:
12122 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12123 
      oprot.writeBool(self.success)
12124 
      oprot.writeFieldEnd()
12125 
    if self.cex is not None:
12126 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12127 
      self.cex.write(oprot)
12128 
      oprot.writeFieldEnd()
12129 
    oprot.writeFieldStop()
12130 
    oprot.writeStructEnd()
12131 
 
12132 
  def validate(self):
12133 
    return
12134 
 
12135 
 
12136 
  def __repr__(self):
12137 
    L = ['%s=%r' % (key, value)
12138 
      for key, value in self.__dict__.iteritems()]
12139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12140 
 
12141 
  def __eq__(self, other):
12142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12143 
 
12144 
  def __ne__(self, other):
12145 
    return not (self == other)
12146 
 
12147 
class checkSimilarItem_args:
12148 
  """
12149 
  Attributes:
12150 
   - brand
12151 
   - modelNumber
12152 
   - modelName
12153 
   - color
12154 
  """
12155 
 
12156 
  thrift_spec = (
12157 
    None, # 0
12158 
    (1, TType.STRING, 'brand', None, None, ), # 1
12159 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
12160 
    (3, TType.STRING, 'modelName', None, None, ), # 3
12161 
    (4, TType.STRING, 'color', None, None, ), # 4
12162 
  )
12163 
 
12164 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
12165 
    self.brand = brand
12166 
    self.modelNumber = modelNumber
12167 
    self.modelName = modelName
12168 
    self.color = color
12169 
 
12170 
  def read(self, iprot):
12171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12173 
      return
12174 
    iprot.readStructBegin()
12175 
    while True:
12176 
      (fname, ftype, fid) = iprot.readFieldBegin()
12177 
      if ftype == TType.STOP:
12178 
        break
12179 
      if fid == 1:
12180 
        if ftype == TType.STRING:
12181 
          self.brand = iprot.readString();
12182 
        else:
12183 
          iprot.skip(ftype)
12184 
      elif fid == 2:
12185 
        if ftype == TType.STRING:
12186 
          self.modelNumber = iprot.readString();
12187 
        else:
12188 
          iprot.skip(ftype)
12189 
      elif fid == 3:
12190 
        if ftype == TType.STRING:
12191 
          self.modelName = iprot.readString();
12192 
        else:
12193 
          iprot.skip(ftype)
12194 
      elif fid == 4:
12195 
        if ftype == TType.STRING:
12196 
          self.color = iprot.readString();
12197 
        else:
12198 
          iprot.skip(ftype)
12199 
      else:
12200 
        iprot.skip(ftype)
12201 
      iprot.readFieldEnd()
12202 
    iprot.readStructEnd()
12203 
 
12204 
  def write(self, oprot):
12205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12207 
      return
12208 
    oprot.writeStructBegin('checkSimilarItem_args')
12209 
    if self.brand is not None:
12210 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
12211 
      oprot.writeString(self.brand)
12212 
      oprot.writeFieldEnd()
12213 
    if self.modelNumber is not None:
12214 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
12215 
      oprot.writeString(self.modelNumber)
12216 
      oprot.writeFieldEnd()
12217 
    if self.modelName is not None:
12218 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12219 
      oprot.writeString(self.modelName)
12220 
      oprot.writeFieldEnd()
12221 
    if self.color is not None:
12222 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12223 
      oprot.writeString(self.color)
12224 
      oprot.writeFieldEnd()
12225 
    oprot.writeFieldStop()
12226 
    oprot.writeStructEnd()
12227 
 
12228 
  def validate(self):
12229 
    return
12230 
 
12231 
 
12232 
  def __repr__(self):
12233 
    L = ['%s=%r' % (key, value)
12234 
      for key, value in self.__dict__.iteritems()]
12235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12236 
 
12237 
  def __eq__(self, other):
12238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12239 
 
12240 
  def __ne__(self, other):
12241 
    return not (self == other)
12242 
 
12243 
class checkSimilarItem_result:
12244 
  """
12245 
  Attributes:
12246 
   - success
12247 
  """
12248 
 
12249 
  thrift_spec = (
12250 
    (0, TType.I64, 'success', None, None, ), # 0
12251 
  )
12252 
 
12253 
  def __init__(self, success=None,):
12254 
    self.success = success
12255 
 
12256 
  def read(self, iprot):
12257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12259 
      return
12260 
    iprot.readStructBegin()
12261 
    while True:
12262 
      (fname, ftype, fid) = iprot.readFieldBegin()
12263 
      if ftype == TType.STOP:
12264 
        break
12265 
      if fid == 0:
12266 
        if ftype == TType.I64:
12267 
          self.success = iprot.readI64();
12268 
        else:
12269 
          iprot.skip(ftype)
12270 
      else:
12271 
        iprot.skip(ftype)
12272 
      iprot.readFieldEnd()
12273 
    iprot.readStructEnd()
12274 
 
12275 
  def write(self, oprot):
12276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12278 
      return
12279 
    oprot.writeStructBegin('checkSimilarItem_result')
12280 
    if self.success is not None:
12281 
      oprot.writeFieldBegin('success', TType.I64, 0)
12282 
      oprot.writeI64(self.success)
12283 
      oprot.writeFieldEnd()
12284 
    oprot.writeFieldStop()
12285 
    oprot.writeStructEnd()
12286 
 
12287 
  def validate(self):
12288 
    return
12289 
 
12290 
 
12291 
  def __repr__(self):
12292 
    L = ['%s=%r' % (key, value)
12293 
      for key, value in self.__dict__.iteritems()]
12294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12295 
 
12296 
  def __eq__(self, other):
12297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12298 
 
12299 
  def __ne__(self, other):
12300 
    return not (self == other)
12301 
 
12302 
class validateRiskyStatus_args:
12303 
  """
12304 
  Attributes:
12305 
   - itemId
12306 
  """
12307 
 
12308 
  thrift_spec = (
12309 
    None, # 0
12310 
    (1, TType.I64, 'itemId', None, None, ), # 1
12311 
  )
12312 
 
12313 
  def __init__(self, itemId=None,):
12314 
    self.itemId = itemId
12315 
 
12316 
  def read(self, iprot):
12317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12319 
      return
12320 
    iprot.readStructBegin()
12321 
    while True:
12322 
      (fname, ftype, fid) = iprot.readFieldBegin()
12323 
      if ftype == TType.STOP:
12324 
        break
12325 
      if fid == 1:
12326 
        if ftype == TType.I64:
12327 
          self.itemId = iprot.readI64();
12328 
        else:
12329 
          iprot.skip(ftype)
12330 
      else:
12331 
        iprot.skip(ftype)
12332 
      iprot.readFieldEnd()
12333 
    iprot.readStructEnd()
12334 
 
12335 
  def write(self, oprot):
12336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12338 
      return
12339 
    oprot.writeStructBegin('validateRiskyStatus_args')
12340 
    if self.itemId is not None:
12341 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12342 
      oprot.writeI64(self.itemId)
12343 
      oprot.writeFieldEnd()
12344 
    oprot.writeFieldStop()
12345 
    oprot.writeStructEnd()
12346 
 
12347 
  def validate(self):
12348 
    return
12349 
 
12350 
 
12351 
  def __repr__(self):
12352 
    L = ['%s=%r' % (key, value)
12353 
      for key, value in self.__dict__.iteritems()]
12354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12355 
 
12356 
  def __eq__(self, other):
12357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12358 
 
12359 
  def __ne__(self, other):
12360 
    return not (self == other)
12361 
 
12362 
class validateRiskyStatus_result:
12363 
 
12364 
  thrift_spec = (
12365 
  )
12366 
 
12367 
  def read(self, iprot):
12368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12370 
      return
12371 
    iprot.readStructBegin()
12372 
    while True:
12373 
      (fname, ftype, fid) = iprot.readFieldBegin()
12374 
      if ftype == TType.STOP:
12375 
        break
12376 
      else:
12377 
        iprot.skip(ftype)
12378 
      iprot.readFieldEnd()
12379 
    iprot.readStructEnd()
12380 
 
12381 
  def write(self, oprot):
12382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12384 
      return
12385 
    oprot.writeStructBegin('validateRiskyStatus_result')
12386 
    oprot.writeFieldStop()
12387 
    oprot.writeStructEnd()
12388 
 
12389 
  def validate(self):
12390 
    return
12391 
 
12392 
 
12393 
  def __repr__(self):
12394 
    L = ['%s=%r' % (key, value)
12395 
      for key, value in self.__dict__.iteritems()]
12396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12397 
 
12398 
  def __eq__(self, other):
12399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12400 
 
12401 
  def __ne__(self, other):
12402 
    return not (self == other)
12403 
 
12404 
class changeItemRiskyFlag_args:
12405 
  """
12406 
  Attributes:
12407 
   - itemId
12408 
   - risky
12409 
  """
12410 
 
12411 
  thrift_spec = (
12412 
    None, # 0
12413 
    (1, TType.I64, 'itemId', None, None, ), # 1
12414 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12415 
  )
12416 
 
12417 
  def __init__(self, itemId=None, risky=None,):
12418 
    self.itemId = itemId
12419 
    self.risky = risky
12420 
 
12421 
  def read(self, iprot):
12422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12424 
      return
12425 
    iprot.readStructBegin()
12426 
    while True:
12427 
      (fname, ftype, fid) = iprot.readFieldBegin()
12428 
      if ftype == TType.STOP:
12429 
        break
12430 
      if fid == 1:
12431 
        if ftype == TType.I64:
12432 
          self.itemId = iprot.readI64();
12433 
        else:
12434 
          iprot.skip(ftype)
12435 
      elif fid == 2:
12436 
        if ftype == TType.BOOL:
12437 
          self.risky = iprot.readBool();
12438 
        else:
12439 
          iprot.skip(ftype)
12440 
      else:
12441 
        iprot.skip(ftype)
12442 
      iprot.readFieldEnd()
12443 
    iprot.readStructEnd()
12444 
 
12445 
  def write(self, oprot):
12446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12448 
      return
12449 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12450 
    if self.itemId is not None:
12451 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12452 
      oprot.writeI64(self.itemId)
12453 
      oprot.writeFieldEnd()
12454 
    if self.risky is not None:
12455 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12456 
      oprot.writeBool(self.risky)
12457 
      oprot.writeFieldEnd()
12458 
    oprot.writeFieldStop()
12459 
    oprot.writeStructEnd()
12460 
 
12461 
  def validate(self):
12462 
    return
12463 
 
12464 
 
12465 
  def __repr__(self):
12466 
    L = ['%s=%r' % (key, value)
12467 
      for key, value in self.__dict__.iteritems()]
12468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12469 
 
12470 
  def __eq__(self, other):
12471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12472 
 
12473 
  def __ne__(self, other):
12474 
    return not (self == other)
12475 
 
12476 
class changeItemRiskyFlag_result:
12477 
 
12478 
  thrift_spec = (
12479 
  )
12480 
 
12481 
  def read(self, iprot):
12482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12484 
      return
12485 
    iprot.readStructBegin()
12486 
    while True:
12487 
      (fname, ftype, fid) = iprot.readFieldBegin()
12488 
      if ftype == TType.STOP:
12489 
        break
12490 
      else:
12491 
        iprot.skip(ftype)
12492 
      iprot.readFieldEnd()
12493 
    iprot.readStructEnd()
12494 
 
12495 
  def write(self, oprot):
12496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12498 
      return
12499 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12500 
    oprot.writeFieldStop()
12501 
    oprot.writeStructEnd()
12502 
 
12503 
  def validate(self):
12504 
    return
12505 
 
12506 
 
12507 
  def __repr__(self):
12508 
    L = ['%s=%r' % (key, value)
12509 
      for key, value in self.__dict__.iteritems()]
12510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12511 
 
12512 
  def __eq__(self, other):
12513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12514 
 
12515 
  def __ne__(self, other):
12516 
    return not (self == other)
12517 
 
12518 
class getItemsByRiskyFlag_args:
12519 
 
12520 
  thrift_spec = (
12521 
  )
12522 
 
12523 
  def read(self, iprot):
12524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12526 
      return
12527 
    iprot.readStructBegin()
12528 
    while True:
12529 
      (fname, ftype, fid) = iprot.readFieldBegin()
12530 
      if ftype == TType.STOP:
12531 
        break
12532 
      else:
12533 
        iprot.skip(ftype)
12534 
      iprot.readFieldEnd()
12535 
    iprot.readStructEnd()
12536 
 
12537 
  def write(self, oprot):
12538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12540 
      return
12541 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12542 
    oprot.writeFieldStop()
12543 
    oprot.writeStructEnd()
12544 
 
12545 
  def validate(self):
12546 
    return
12547 
 
12548 
 
12549 
  def __repr__(self):
12550 
    L = ['%s=%r' % (key, value)
12551 
      for key, value in self.__dict__.iteritems()]
12552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12553 
 
12554 
  def __eq__(self, other):
12555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12556 
 
12557 
  def __ne__(self, other):
12558 
    return not (self == other)
12559 
 
12560 
class getItemsByRiskyFlag_result:
12561 
  """
12562 
  Attributes:
12563 
   - success
12564 
  """
12565 
 
12566 
  thrift_spec = (
12567 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12568 
  )
12569 
 
12570 
  def __init__(self, success=None,):
12571 
    self.success = success
12572 
 
12573 
  def read(self, iprot):
12574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12576 
      return
12577 
    iprot.readStructBegin()
12578 
    while True:
12579 
      (fname, ftype, fid) = iprot.readFieldBegin()
12580 
      if ftype == TType.STOP:
12581 
        break
12582 
      if fid == 0:
12583 
        if ftype == TType.LIST:
12584 
          self.success = []
7438 amit.gupta 12585 
          (_etype205, _size202) = iprot.readListBegin()
12586 
          for _i206 in xrange(_size202):
12587 
            _elem207 = Item()
12588 
            _elem207.read(iprot)
12589 
            self.success.append(_elem207)
5944 mandeep.dh 12590 
          iprot.readListEnd()
12591 
        else:
12592 
          iprot.skip(ftype)
12593 
      else:
12594 
        iprot.skip(ftype)
12595 
      iprot.readFieldEnd()
12596 
    iprot.readStructEnd()
12597 
 
12598 
  def write(self, oprot):
12599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12601 
      return
12602 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12603 
    if self.success is not None:
12604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12606 
      for iter208 in self.success:
12607 
        iter208.write(oprot)
5944 mandeep.dh 12608 
      oprot.writeListEnd()
12609 
      oprot.writeFieldEnd()
12610 
    oprot.writeFieldStop()
12611 
    oprot.writeStructEnd()
12612 
 
12613 
  def validate(self):
12614 
    return
12615 
 
12616 
 
12617 
  def __repr__(self):
12618 
    L = ['%s=%r' % (key, value)
12619 
      for key, value in self.__dict__.iteritems()]
12620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12621 
 
12622 
  def __eq__(self, other):
12623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12624 
 
12625 
  def __ne__(self, other):
12626 
    return not (self == other)
12627 
 
12628 
class getItemsForMasterSheet_args:
12629 
  """
12630 
  Attributes:
12631 
   - category
12632 
   - brand
12633 
  """
12634 
 
12635 
  thrift_spec = (
12636 
    None, # 0
12637 
    (1, TType.STRING, 'category', None, None, ), # 1
12638 
    (2, TType.STRING, 'brand', None, None, ), # 2
12639 
  )
12640 
 
12641 
  def __init__(self, category=None, brand=None,):
12642 
    self.category = category
12643 
    self.brand = brand
12644 
 
12645 
  def read(self, iprot):
12646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12648 
      return
12649 
    iprot.readStructBegin()
12650 
    while True:
12651 
      (fname, ftype, fid) = iprot.readFieldBegin()
12652 
      if ftype == TType.STOP:
12653 
        break
12654 
      if fid == 1:
12655 
        if ftype == TType.STRING:
12656 
          self.category = iprot.readString();
12657 
        else:
12658 
          iprot.skip(ftype)
12659 
      elif fid == 2:
12660 
        if ftype == TType.STRING:
12661 
          self.brand = iprot.readString();
12662 
        else:
12663 
          iprot.skip(ftype)
12664 
      else:
12665 
        iprot.skip(ftype)
12666 
      iprot.readFieldEnd()
12667 
    iprot.readStructEnd()
12668 
 
12669 
  def write(self, oprot):
12670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12672 
      return
12673 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12674 
    if self.category is not None:
12675 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12676 
      oprot.writeString(self.category)
12677 
      oprot.writeFieldEnd()
12678 
    if self.brand is not None:
12679 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12680 
      oprot.writeString(self.brand)
12681 
      oprot.writeFieldEnd()
12682 
    oprot.writeFieldStop()
12683 
    oprot.writeStructEnd()
12684 
 
12685 
  def validate(self):
12686 
    return
12687 
 
12688 
 
12689 
  def __repr__(self):
12690 
    L = ['%s=%r' % (key, value)
12691 
      for key, value in self.__dict__.iteritems()]
12692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12693 
 
12694 
  def __eq__(self, other):
12695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12696 
 
12697 
  def __ne__(self, other):
12698 
    return not (self == other)
12699 
 
12700 
class getItemsForMasterSheet_result:
12701 
  """
12702 
  Attributes:
12703 
   - success
12704 
  """
12705 
 
12706 
  thrift_spec = (
12707 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12708 
  )
12709 
 
12710 
  def __init__(self, success=None,):
12711 
    self.success = success
12712 
 
12713 
  def read(self, iprot):
12714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12716 
      return
12717 
    iprot.readStructBegin()
12718 
    while True:
12719 
      (fname, ftype, fid) = iprot.readFieldBegin()
12720 
      if ftype == TType.STOP:
12721 
        break
12722 
      if fid == 0:
12723 
        if ftype == TType.LIST:
12724 
          self.success = []
7438 amit.gupta 12725 
          (_etype212, _size209) = iprot.readListBegin()
12726 
          for _i213 in xrange(_size209):
12727 
            _elem214 = Item()
12728 
            _elem214.read(iprot)
12729 
            self.success.append(_elem214)
5944 mandeep.dh 12730 
          iprot.readListEnd()
12731 
        else:
12732 
          iprot.skip(ftype)
12733 
      else:
12734 
        iprot.skip(ftype)
12735 
      iprot.readFieldEnd()
12736 
    iprot.readStructEnd()
12737 
 
12738 
  def write(self, oprot):
12739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12741 
      return
12742 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12743 
    if self.success is not None:
12744 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12745 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12746 
      for iter215 in self.success:
12747 
        iter215.write(oprot)
5944 mandeep.dh 12748 
      oprot.writeListEnd()
12749 
      oprot.writeFieldEnd()
12750 
    oprot.writeFieldStop()
12751 
    oprot.writeStructEnd()
12752 
 
12753 
  def validate(self):
12754 
    return
12755 
 
12756 
 
12757 
  def __repr__(self):
12758 
    L = ['%s=%r' % (key, value)
12759 
      for key, value in self.__dict__.iteritems()]
12760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12761 
 
12762 
  def __eq__(self, other):
12763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12764 
 
12765 
  def __ne__(self, other):
12766 
    return not (self == other)
12767 
 
12768 
class getSimilarItemsCatalogIds_args:
12769 
  """
12770 
  Attributes:
12771 
   - beginIndex
12772 
   - totalItems
12773 
   - itemId
12774 
  """
12775 
 
12776 
  thrift_spec = (
12777 
    None, # 0
12778 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12779 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12780 
    (3, TType.I64, 'itemId', None, None, ), # 3
12781 
  )
12782 
 
12783 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12784 
    self.beginIndex = beginIndex
12785 
    self.totalItems = totalItems
12786 
    self.itemId = itemId
12787 
 
12788 
  def read(self, iprot):
12789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12791 
      return
12792 
    iprot.readStructBegin()
12793 
    while True:
12794 
      (fname, ftype, fid) = iprot.readFieldBegin()
12795 
      if ftype == TType.STOP:
12796 
        break
12797 
      if fid == 1:
12798 
        if ftype == TType.I64:
12799 
          self.beginIndex = iprot.readI64();
12800 
        else:
12801 
          iprot.skip(ftype)
12802 
      elif fid == 2:
12803 
        if ftype == TType.I64:
12804 
          self.totalItems = iprot.readI64();
12805 
        else:
12806 
          iprot.skip(ftype)
12807 
      elif fid == 3:
12808 
        if ftype == TType.I64:
12809 
          self.itemId = iprot.readI64();
12810 
        else:
12811 
          iprot.skip(ftype)
12812 
      else:
12813 
        iprot.skip(ftype)
12814 
      iprot.readFieldEnd()
12815 
    iprot.readStructEnd()
12816 
 
12817 
  def write(self, oprot):
12818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12820 
      return
12821 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12822 
    if self.beginIndex is not None:
12823 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12824 
      oprot.writeI64(self.beginIndex)
12825 
      oprot.writeFieldEnd()
12826 
    if self.totalItems is not None:
12827 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12828 
      oprot.writeI64(self.totalItems)
12829 
      oprot.writeFieldEnd()
12830 
    if self.itemId is not None:
12831 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12832 
      oprot.writeI64(self.itemId)
12833 
      oprot.writeFieldEnd()
12834 
    oprot.writeFieldStop()
12835 
    oprot.writeStructEnd()
12836 
 
12837 
  def validate(self):
12838 
    return
12839 
 
12840 
 
12841 
  def __repr__(self):
12842 
    L = ['%s=%r' % (key, value)
12843 
      for key, value in self.__dict__.iteritems()]
12844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12845 
 
12846 
  def __eq__(self, other):
12847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12848 
 
12849 
  def __ne__(self, other):
12850 
    return not (self == other)
12851 
 
12852 
class getSimilarItemsCatalogIds_result:
12853 
  """
12854 
  Attributes:
12855 
   - success
12856 
  """
12857 
 
12858 
  thrift_spec = (
12859 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12860 
  )
12861 
 
12862 
  def __init__(self, success=None,):
12863 
    self.success = success
12864 
 
12865 
  def read(self, iprot):
12866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12868 
      return
12869 
    iprot.readStructBegin()
12870 
    while True:
12871 
      (fname, ftype, fid) = iprot.readFieldBegin()
12872 
      if ftype == TType.STOP:
12873 
        break
12874 
      if fid == 0:
12875 
        if ftype == TType.LIST:
12876 
          self.success = []
7438 amit.gupta 12877 
          (_etype219, _size216) = iprot.readListBegin()
12878 
          for _i220 in xrange(_size216):
12879 
            _elem221 = iprot.readI64();
12880 
            self.success.append(_elem221)
5944 mandeep.dh 12881 
          iprot.readListEnd()
12882 
        else:
12883 
          iprot.skip(ftype)
12884 
      else:
12885 
        iprot.skip(ftype)
12886 
      iprot.readFieldEnd()
12887 
    iprot.readStructEnd()
12888 
 
12889 
  def write(self, oprot):
12890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12892 
      return
12893 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12894 
    if self.success is not None:
12895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12896 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12897 
      for iter222 in self.success:
12898 
        oprot.writeI64(iter222)
5944 mandeep.dh 12899 
      oprot.writeListEnd()
12900 
      oprot.writeFieldEnd()
12901 
    oprot.writeFieldStop()
12902 
    oprot.writeStructEnd()
12903 
 
12904 
  def validate(self):
12905 
    return
12906 
 
12907 
 
12908 
  def __repr__(self):
12909 
    L = ['%s=%r' % (key, value)
12910 
      for key, value in self.__dict__.iteritems()]
12911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12912 
 
12913 
  def __eq__(self, other):
12914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12915 
 
12916 
  def __ne__(self, other):
12917 
    return not (self == other)
12918 
 
12919 
class addProductNotification_args:
12920 
  """
12921 
  Attributes:
12922 
   - itemId
12923 
   - email
12924 
  """
12925 
 
12926 
  thrift_spec = None
12927 
  def __init__(self, itemId=None, email=None,):
12928 
    self.itemId = itemId
12929 
    self.email = email
12930 
 
12931 
  def read(self, iprot):
12932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12934 
      return
12935 
    iprot.readStructBegin()
12936 
    while True:
12937 
      (fname, ftype, fid) = iprot.readFieldBegin()
12938 
      if ftype == TType.STOP:
12939 
        break
12940 
      if fid == -1:
12941 
        if ftype == TType.I64:
12942 
          self.itemId = iprot.readI64();
12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      elif fid == -2:
12946 
        if ftype == TType.STRING:
12947 
          self.email = iprot.readString();
12948 
        else:
12949 
          iprot.skip(ftype)
12950 
      else:
12951 
        iprot.skip(ftype)
12952 
      iprot.readFieldEnd()
12953 
    iprot.readStructEnd()
12954 
 
12955 
  def write(self, oprot):
12956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12958 
      return
12959 
    oprot.writeStructBegin('addProductNotification_args')
12960 
    if self.email is not None:
12961 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12962 
      oprot.writeString(self.email)
12963 
      oprot.writeFieldEnd()
12964 
    if self.itemId is not None:
12965 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12966 
      oprot.writeI64(self.itemId)
12967 
      oprot.writeFieldEnd()
12968 
    oprot.writeFieldStop()
12969 
    oprot.writeStructEnd()
12970 
 
12971 
  def validate(self):
12972 
    return
12973 
 
12974 
 
12975 
  def __repr__(self):
12976 
    L = ['%s=%r' % (key, value)
12977 
      for key, value in self.__dict__.iteritems()]
12978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12979 
 
12980 
  def __eq__(self, other):
12981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12982 
 
12983 
  def __ne__(self, other):
12984 
    return not (self == other)
12985 
 
12986 
class addProductNotification_result:
12987 
  """
12988 
  Attributes:
12989 
   - success
12990 
  """
12991 
 
12992 
  thrift_spec = (
12993 
    (0, TType.BOOL, 'success', None, None, ), # 0
12994 
  )
12995 
 
12996 
  def __init__(self, success=None,):
12997 
    self.success = success
12998 
 
12999 
  def read(self, iprot):
13000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13002 
      return
13003 
    iprot.readStructBegin()
13004 
    while True:
13005 
      (fname, ftype, fid) = iprot.readFieldBegin()
13006 
      if ftype == TType.STOP:
13007 
        break
13008 
      if fid == 0:
13009 
        if ftype == TType.BOOL:
13010 
          self.success = iprot.readBool();
13011 
        else:
13012 
          iprot.skip(ftype)
13013 
      else:
13014 
        iprot.skip(ftype)
13015 
      iprot.readFieldEnd()
13016 
    iprot.readStructEnd()
13017 
 
13018 
  def write(self, oprot):
13019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13021 
      return
13022 
    oprot.writeStructBegin('addProductNotification_result')
13023 
    if self.success is not None:
13024 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13025 
      oprot.writeBool(self.success)
13026 
      oprot.writeFieldEnd()
13027 
    oprot.writeFieldStop()
13028 
    oprot.writeStructEnd()
13029 
 
13030 
  def validate(self):
13031 
    return
13032 
 
13033 
 
13034 
  def __repr__(self):
13035 
    L = ['%s=%r' % (key, value)
13036 
      for key, value in self.__dict__.iteritems()]
13037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13038 
 
13039 
  def __eq__(self, other):
13040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13041 
 
13042 
  def __ne__(self, other):
13043 
    return not (self == other)
13044 
 
13045 
class sendProductNotifications_args:
13046 
 
13047 
  thrift_spec = (
13048 
  )
13049 
 
13050 
  def read(self, iprot):
13051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13053 
      return
13054 
    iprot.readStructBegin()
13055 
    while True:
13056 
      (fname, ftype, fid) = iprot.readFieldBegin()
13057 
      if ftype == TType.STOP:
13058 
        break
13059 
      else:
13060 
        iprot.skip(ftype)
13061 
      iprot.readFieldEnd()
13062 
    iprot.readStructEnd()
13063 
 
13064 
  def write(self, oprot):
13065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13067 
      return
13068 
    oprot.writeStructBegin('sendProductNotifications_args')
13069 
    oprot.writeFieldStop()
13070 
    oprot.writeStructEnd()
13071 
 
13072 
  def validate(self):
13073 
    return
13074 
 
13075 
 
13076 
  def __repr__(self):
13077 
    L = ['%s=%r' % (key, value)
13078 
      for key, value in self.__dict__.iteritems()]
13079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13080 
 
13081 
  def __eq__(self, other):
13082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13083 
 
13084 
  def __ne__(self, other):
13085 
    return not (self == other)
13086 
 
13087 
class sendProductNotifications_result:
13088 
  """
13089 
  Attributes:
13090 
   - success
13091 
  """
13092 
 
13093 
  thrift_spec = (
13094 
    (0, TType.BOOL, 'success', None, None, ), # 0
13095 
  )
13096 
 
13097 
  def __init__(self, success=None,):
13098 
    self.success = success
13099 
 
13100 
  def read(self, iprot):
13101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13103 
      return
13104 
    iprot.readStructBegin()
13105 
    while True:
13106 
      (fname, ftype, fid) = iprot.readFieldBegin()
13107 
      if ftype == TType.STOP:
13108 
        break
13109 
      if fid == 0:
13110 
        if ftype == TType.BOOL:
13111 
          self.success = iprot.readBool();
13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      else:
13115 
        iprot.skip(ftype)
13116 
      iprot.readFieldEnd()
13117 
    iprot.readStructEnd()
13118 
 
13119 
  def write(self, oprot):
13120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13122 
      return
13123 
    oprot.writeStructBegin('sendProductNotifications_result')
13124 
    if self.success is not None:
13125 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13126 
      oprot.writeBool(self.success)
13127 
      oprot.writeFieldEnd()
13128 
    oprot.writeFieldStop()
13129 
    oprot.writeStructEnd()
13130 
 
13131 
  def validate(self):
13132 
    return
13133 
 
13134 
 
13135 
  def __repr__(self):
13136 
    L = ['%s=%r' % (key, value)
13137 
      for key, value in self.__dict__.iteritems()]
13138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13139 
 
13140 
  def __eq__(self, other):
13141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13142 
 
13143 
  def __ne__(self, other):
13144 
    return not (self == other)
13145 
 
13146 
class getAllBrandsByCategory_args:
13147 
  """
13148 
  Attributes:
13149 
   - categoryId
13150 
  """
13151 
 
13152 
  thrift_spec = (
13153 
    None, # 0
13154 
    (1, TType.I64, 'categoryId', None, None, ), # 1
13155 
  )
13156 
 
13157 
  def __init__(self, categoryId=None,):
13158 
    self.categoryId = categoryId
13159 
 
13160 
  def read(self, iprot):
13161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13163 
      return
13164 
    iprot.readStructBegin()
13165 
    while True:
13166 
      (fname, ftype, fid) = iprot.readFieldBegin()
13167 
      if ftype == TType.STOP:
13168 
        break
13169 
      if fid == 1:
13170 
        if ftype == TType.I64:
13171 
          self.categoryId = iprot.readI64();
13172 
        else:
13173 
          iprot.skip(ftype)
13174 
      else:
13175 
        iprot.skip(ftype)
13176 
      iprot.readFieldEnd()
13177 
    iprot.readStructEnd()
13178 
 
13179 
  def write(self, oprot):
13180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13182 
      return
13183 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
13184 
    if self.categoryId is not None:
13185 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
13186 
      oprot.writeI64(self.categoryId)
13187 
      oprot.writeFieldEnd()
13188 
    oprot.writeFieldStop()
13189 
    oprot.writeStructEnd()
13190 
 
13191 
  def validate(self):
13192 
    return
13193 
 
13194 
 
13195 
  def __repr__(self):
13196 
    L = ['%s=%r' % (key, value)
13197 
      for key, value in self.__dict__.iteritems()]
13198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13199 
 
13200 
  def __eq__(self, other):
13201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13202 
 
13203 
  def __ne__(self, other):
13204 
    return not (self == other)
13205 
 
13206 
class getAllBrandsByCategory_result:
13207 
  """
13208 
  Attributes:
13209 
   - success
13210 
  """
13211 
 
13212 
  thrift_spec = (
13213 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13214 
  )
13215 
 
13216 
  def __init__(self, success=None,):
13217 
    self.success = success
13218 
 
13219 
  def read(self, iprot):
13220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13222 
      return
13223 
    iprot.readStructBegin()
13224 
    while True:
13225 
      (fname, ftype, fid) = iprot.readFieldBegin()
13226 
      if ftype == TType.STOP:
13227 
        break
13228 
      if fid == 0:
13229 
        if ftype == TType.LIST:
13230 
          self.success = []
7438 amit.gupta 13231 
          (_etype226, _size223) = iprot.readListBegin()
13232 
          for _i227 in xrange(_size223):
13233 
            _elem228 = iprot.readString();
13234 
            self.success.append(_elem228)
5944 mandeep.dh 13235 
          iprot.readListEnd()
13236 
        else:
13237 
          iprot.skip(ftype)
13238 
      else:
13239 
        iprot.skip(ftype)
13240 
      iprot.readFieldEnd()
13241 
    iprot.readStructEnd()
13242 
 
13243 
  def write(self, oprot):
13244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13246 
      return
13247 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
13248 
    if self.success is not None:
13249 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13250 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13251 
      for iter229 in self.success:
13252 
        oprot.writeString(iter229)
5944 mandeep.dh 13253 
      oprot.writeListEnd()
13254 
      oprot.writeFieldEnd()
13255 
    oprot.writeFieldStop()
13256 
    oprot.writeStructEnd()
13257 
 
13258 
  def validate(self):
13259 
    return
13260 
 
13261 
 
13262 
  def __repr__(self):
13263 
    L = ['%s=%r' % (key, value)
13264 
      for key, value in self.__dict__.iteritems()]
13265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13266 
 
13267 
  def __eq__(self, other):
13268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13269 
 
13270 
  def __ne__(self, other):
13271 
    return not (self == other)
13272 
 
13273 
class getAllBrands_args:
13274 
 
13275 
  thrift_spec = (
13276 
  )
13277 
 
13278 
  def read(self, iprot):
13279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13281 
      return
13282 
    iprot.readStructBegin()
13283 
    while True:
13284 
      (fname, ftype, fid) = iprot.readFieldBegin()
13285 
      if ftype == TType.STOP:
13286 
        break
13287 
      else:
13288 
        iprot.skip(ftype)
13289 
      iprot.readFieldEnd()
13290 
    iprot.readStructEnd()
13291 
 
13292 
  def write(self, oprot):
13293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13295 
      return
13296 
    oprot.writeStructBegin('getAllBrands_args')
13297 
    oprot.writeFieldStop()
13298 
    oprot.writeStructEnd()
13299 
 
13300 
  def validate(self):
13301 
    return
13302 
 
13303 
 
13304 
  def __repr__(self):
13305 
    L = ['%s=%r' % (key, value)
13306 
      for key, value in self.__dict__.iteritems()]
13307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13308 
 
13309 
  def __eq__(self, other):
13310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13311 
 
13312 
  def __ne__(self, other):
13313 
    return not (self == other)
13314 
 
13315 
class getAllBrands_result:
13316 
  """
13317 
  Attributes:
13318 
   - success
13319 
  """
13320 
 
13321 
  thrift_spec = (
13322 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13323 
  )
13324 
 
13325 
  def __init__(self, success=None,):
13326 
    self.success = success
13327 
 
13328 
  def read(self, iprot):
13329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13331 
      return
13332 
    iprot.readStructBegin()
13333 
    while True:
13334 
      (fname, ftype, fid) = iprot.readFieldBegin()
13335 
      if ftype == TType.STOP:
13336 
        break
13337 
      if fid == 0:
13338 
        if ftype == TType.LIST:
13339 
          self.success = []
7438 amit.gupta 13340 
          (_etype233, _size230) = iprot.readListBegin()
13341 
          for _i234 in xrange(_size230):
13342 
            _elem235 = iprot.readString();
13343 
            self.success.append(_elem235)
5944 mandeep.dh 13344 
          iprot.readListEnd()
13345 
        else:
13346 
          iprot.skip(ftype)
13347 
      else:
13348 
        iprot.skip(ftype)
13349 
      iprot.readFieldEnd()
13350 
    iprot.readStructEnd()
13351 
 
13352 
  def write(self, oprot):
13353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13355 
      return
13356 
    oprot.writeStructBegin('getAllBrands_result')
13357 
    if self.success is not None:
13358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13359 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13360 
      for iter236 in self.success:
13361 
        oprot.writeString(iter236)
5944 mandeep.dh 13362 
      oprot.writeListEnd()
13363 
      oprot.writeFieldEnd()
13364 
    oprot.writeFieldStop()
13365 
    oprot.writeStructEnd()
13366 
 
13367 
  def validate(self):
13368 
    return
13369 
 
13370 
 
13371 
  def __repr__(self):
13372 
    L = ['%s=%r' % (key, value)
13373 
      for key, value in self.__dict__.iteritems()]
13374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13375 
 
13376 
  def __eq__(self, other):
13377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13378 
 
13379 
  def __ne__(self, other):
13380 
    return not (self == other)
13381 
 
13382 
class getAllSources_args:
13383 
 
13384 
  thrift_spec = (
13385 
  )
13386 
 
13387 
  def read(self, iprot):
13388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13390 
      return
13391 
    iprot.readStructBegin()
13392 
    while True:
13393 
      (fname, ftype, fid) = iprot.readFieldBegin()
13394 
      if ftype == TType.STOP:
13395 
        break
13396 
      else:
13397 
        iprot.skip(ftype)
13398 
      iprot.readFieldEnd()
13399 
    iprot.readStructEnd()
13400 
 
13401 
  def write(self, oprot):
13402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13404 
      return
13405 
    oprot.writeStructBegin('getAllSources_args')
13406 
    oprot.writeFieldStop()
13407 
    oprot.writeStructEnd()
13408 
 
13409 
  def validate(self):
13410 
    return
13411 
 
13412 
 
13413 
  def __repr__(self):
13414 
    L = ['%s=%r' % (key, value)
13415 
      for key, value in self.__dict__.iteritems()]
13416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13417 
 
13418 
  def __eq__(self, other):
13419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13420 
 
13421 
  def __ne__(self, other):
13422 
    return not (self == other)
13423 
 
13424 
class getAllSources_result:
13425 
  """
13426 
  Attributes:
13427 
   - success
13428 
  """
13429 
 
13430 
  thrift_spec = (
13431 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13432 
  )
13433 
 
13434 
  def __init__(self, success=None,):
13435 
    self.success = success
13436 
 
13437 
  def read(self, iprot):
13438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13440 
      return
13441 
    iprot.readStructBegin()
13442 
    while True:
13443 
      (fname, ftype, fid) = iprot.readFieldBegin()
13444 
      if ftype == TType.STOP:
13445 
        break
13446 
      if fid == 0:
13447 
        if ftype == TType.LIST:
13448 
          self.success = []
7438 amit.gupta 13449 
          (_etype240, _size237) = iprot.readListBegin()
13450 
          for _i241 in xrange(_size237):
13451 
            _elem242 = Source()
13452 
            _elem242.read(iprot)
13453 
            self.success.append(_elem242)
5944 mandeep.dh 13454 
          iprot.readListEnd()
13455 
        else:
13456 
          iprot.skip(ftype)
13457 
      else:
13458 
        iprot.skip(ftype)
13459 
      iprot.readFieldEnd()
13460 
    iprot.readStructEnd()
13461 
 
13462 
  def write(self, oprot):
13463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13465 
      return
13466 
    oprot.writeStructBegin('getAllSources_result')
13467 
    if self.success is not None:
13468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13469 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13470 
      for iter243 in self.success:
13471 
        iter243.write(oprot)
5944 mandeep.dh 13472 
      oprot.writeListEnd()
13473 
      oprot.writeFieldEnd()
13474 
    oprot.writeFieldStop()
13475 
    oprot.writeStructEnd()
13476 
 
13477 
  def validate(self):
13478 
    return
13479 
 
13480 
 
13481 
  def __repr__(self):
13482 
    L = ['%s=%r' % (key, value)
13483 
      for key, value in self.__dict__.iteritems()]
13484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13485 
 
13486 
  def __eq__(self, other):
13487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13488 
 
13489 
  def __ne__(self, other):
13490 
    return not (self == other)
13491 
 
13492 
class getItemPricingBySource_args:
13493 
  """
13494 
  Attributes:
13495 
   - itemId
13496 
   - sourceId
13497 
  """
13498 
 
13499 
  thrift_spec = (
13500 
    None, # 0
13501 
    (1, TType.I64, 'itemId', None, None, ), # 1
13502 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13503 
  )
13504 
 
13505 
  def __init__(self, itemId=None, sourceId=None,):
13506 
    self.itemId = itemId
13507 
    self.sourceId = sourceId
13508 
 
13509 
  def read(self, iprot):
13510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13512 
      return
13513 
    iprot.readStructBegin()
13514 
    while True:
13515 
      (fname, ftype, fid) = iprot.readFieldBegin()
13516 
      if ftype == TType.STOP:
13517 
        break
13518 
      if fid == 1:
13519 
        if ftype == TType.I64:
13520 
          self.itemId = iprot.readI64();
13521 
        else:
13522 
          iprot.skip(ftype)
13523 
      elif fid == 2:
13524 
        if ftype == TType.I64:
13525 
          self.sourceId = iprot.readI64();
13526 
        else:
13527 
          iprot.skip(ftype)
13528 
      else:
13529 
        iprot.skip(ftype)
13530 
      iprot.readFieldEnd()
13531 
    iprot.readStructEnd()
13532 
 
13533 
  def write(self, oprot):
13534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13536 
      return
13537 
    oprot.writeStructBegin('getItemPricingBySource_args')
13538 
    if self.itemId is not None:
13539 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13540 
      oprot.writeI64(self.itemId)
13541 
      oprot.writeFieldEnd()
13542 
    if self.sourceId is not None:
13543 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13544 
      oprot.writeI64(self.sourceId)
13545 
      oprot.writeFieldEnd()
13546 
    oprot.writeFieldStop()
13547 
    oprot.writeStructEnd()
13548 
 
13549 
  def validate(self):
13550 
    return
13551 
 
13552 
 
13553 
  def __repr__(self):
13554 
    L = ['%s=%r' % (key, value)
13555 
      for key, value in self.__dict__.iteritems()]
13556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13557 
 
13558 
  def __eq__(self, other):
13559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13560 
 
13561 
  def __ne__(self, other):
13562 
    return not (self == other)
13563 
 
13564 
class getItemPricingBySource_result:
13565 
  """
13566 
  Attributes:
13567 
   - success
13568 
   - cex
13569 
  """
13570 
 
13571 
  thrift_spec = (
13572 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13573 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13574 
  )
13575 
 
13576 
  def __init__(self, success=None, cex=None,):
13577 
    self.success = success
13578 
    self.cex = cex
13579 
 
13580 
  def read(self, iprot):
13581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13583 
      return
13584 
    iprot.readStructBegin()
13585 
    while True:
13586 
      (fname, ftype, fid) = iprot.readFieldBegin()
13587 
      if ftype == TType.STOP:
13588 
        break
13589 
      if fid == 0:
13590 
        if ftype == TType.STRUCT:
13591 
          self.success = SourceItemPricing()
13592 
          self.success.read(iprot)
13593 
        else:
13594 
          iprot.skip(ftype)
13595 
      elif fid == 1:
13596 
        if ftype == TType.STRUCT:
13597 
          self.cex = CatalogServiceException()
13598 
          self.cex.read(iprot)
13599 
        else:
13600 
          iprot.skip(ftype)
13601 
      else:
13602 
        iprot.skip(ftype)
13603 
      iprot.readFieldEnd()
13604 
    iprot.readStructEnd()
13605 
 
13606 
  def write(self, oprot):
13607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13609 
      return
13610 
    oprot.writeStructBegin('getItemPricingBySource_result')
13611 
    if self.success is not None:
13612 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13613 
      self.success.write(oprot)
13614 
      oprot.writeFieldEnd()
13615 
    if self.cex is not None:
13616 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13617 
      self.cex.write(oprot)
13618 
      oprot.writeFieldEnd()
13619 
    oprot.writeFieldStop()
13620 
    oprot.writeStructEnd()
13621 
 
13622 
  def validate(self):
13623 
    return
13624 
 
13625 
 
13626 
  def __repr__(self):
13627 
    L = ['%s=%r' % (key, value)
13628 
      for key, value in self.__dict__.iteritems()]
13629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13630 
 
13631 
  def __eq__(self, other):
13632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13633 
 
13634 
  def __ne__(self, other):
13635 
    return not (self == other)
13636 
 
13637 
class addSourceItemPricing_args:
13638 
  """
13639 
  Attributes:
13640 
   - sourceItemPricing
13641 
  """
13642 
 
13643 
  thrift_spec = (
13644 
    None, # 0
13645 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13646 
  )
13647 
 
13648 
  def __init__(self, sourceItemPricing=None,):
13649 
    self.sourceItemPricing = sourceItemPricing
13650 
 
13651 
  def read(self, iprot):
13652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13654 
      return
13655 
    iprot.readStructBegin()
13656 
    while True:
13657 
      (fname, ftype, fid) = iprot.readFieldBegin()
13658 
      if ftype == TType.STOP:
13659 
        break
13660 
      if fid == 1:
13661 
        if ftype == TType.STRUCT:
13662 
          self.sourceItemPricing = SourceItemPricing()
13663 
          self.sourceItemPricing.read(iprot)
13664 
        else:
13665 
          iprot.skip(ftype)
13666 
      else:
13667 
        iprot.skip(ftype)
13668 
      iprot.readFieldEnd()
13669 
    iprot.readStructEnd()
13670 
 
13671 
  def write(self, oprot):
13672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13674 
      return
13675 
    oprot.writeStructBegin('addSourceItemPricing_args')
13676 
    if self.sourceItemPricing is not None:
13677 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13678 
      self.sourceItemPricing.write(oprot)
13679 
      oprot.writeFieldEnd()
13680 
    oprot.writeFieldStop()
13681 
    oprot.writeStructEnd()
13682 
 
13683 
  def validate(self):
13684 
    return
13685 
 
13686 
 
13687 
  def __repr__(self):
13688 
    L = ['%s=%r' % (key, value)
13689 
      for key, value in self.__dict__.iteritems()]
13690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13691 
 
13692 
  def __eq__(self, other):
13693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13694 
 
13695 
  def __ne__(self, other):
13696 
    return not (self == other)
13697 
 
13698 
class addSourceItemPricing_result:
13699 
  """
13700 
  Attributes:
13701 
   - cex
13702 
  """
13703 
 
13704 
  thrift_spec = (
13705 
    None, # 0
13706 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13707 
  )
13708 
 
13709 
  def __init__(self, cex=None,):
13710 
    self.cex = cex
13711 
 
13712 
  def read(self, iprot):
13713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13715 
      return
13716 
    iprot.readStructBegin()
13717 
    while True:
13718 
      (fname, ftype, fid) = iprot.readFieldBegin()
13719 
      if ftype == TType.STOP:
13720 
        break
13721 
      if fid == 1:
13722 
        if ftype == TType.STRUCT:
13723 
          self.cex = CatalogServiceException()
13724 
          self.cex.read(iprot)
13725 
        else:
13726 
          iprot.skip(ftype)
13727 
      else:
13728 
        iprot.skip(ftype)
13729 
      iprot.readFieldEnd()
13730 
    iprot.readStructEnd()
13731 
 
13732 
  def write(self, oprot):
13733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13735 
      return
13736 
    oprot.writeStructBegin('addSourceItemPricing_result')
13737 
    if self.cex is not None:
13738 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13739 
      self.cex.write(oprot)
13740 
      oprot.writeFieldEnd()
13741 
    oprot.writeFieldStop()
13742 
    oprot.writeStructEnd()
13743 
 
13744 
  def validate(self):
13745 
    return
13746 
 
13747 
 
13748 
  def __repr__(self):
13749 
    L = ['%s=%r' % (key, value)
13750 
      for key, value in self.__dict__.iteritems()]
13751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13752 
 
13753 
  def __eq__(self, other):
13754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13755 
 
13756 
  def __ne__(self, other):
13757 
    return not (self == other)
13758 
 
13759 
class getAllSourcePricing_args:
13760 
  """
13761 
  Attributes:
13762 
   - itemId
13763 
  """
13764 
 
13765 
  thrift_spec = (
13766 
    None, # 0
13767 
    (1, TType.I64, 'itemId', None, None, ), # 1
13768 
  )
13769 
 
13770 
  def __init__(self, itemId=None,):
13771 
    self.itemId = itemId
13772 
 
13773 
  def read(self, iprot):
13774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13776 
      return
13777 
    iprot.readStructBegin()
13778 
    while True:
13779 
      (fname, ftype, fid) = iprot.readFieldBegin()
13780 
      if ftype == TType.STOP:
13781 
        break
13782 
      if fid == 1:
13783 
        if ftype == TType.I64:
13784 
          self.itemId = iprot.readI64();
13785 
        else:
13786 
          iprot.skip(ftype)
13787 
      else:
13788 
        iprot.skip(ftype)
13789 
      iprot.readFieldEnd()
13790 
    iprot.readStructEnd()
13791 
 
13792 
  def write(self, oprot):
13793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13795 
      return
13796 
    oprot.writeStructBegin('getAllSourcePricing_args')
13797 
    if self.itemId is not None:
13798 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13799 
      oprot.writeI64(self.itemId)
13800 
      oprot.writeFieldEnd()
13801 
    oprot.writeFieldStop()
13802 
    oprot.writeStructEnd()
13803 
 
13804 
  def validate(self):
13805 
    return
13806 
 
13807 
 
13808 
  def __repr__(self):
13809 
    L = ['%s=%r' % (key, value)
13810 
      for key, value in self.__dict__.iteritems()]
13811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13812 
 
13813 
  def __eq__(self, other):
13814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13815 
 
13816 
  def __ne__(self, other):
13817 
    return not (self == other)
13818 
 
13819 
class getAllSourcePricing_result:
13820 
  """
13821 
  Attributes:
13822 
   - success
13823 
   - cex
13824 
  """
13825 
 
13826 
  thrift_spec = (
13827 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13828 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13829 
  )
13830 
 
13831 
  def __init__(self, success=None, cex=None,):
13832 
    self.success = success
13833 
    self.cex = cex
13834 
 
13835 
  def read(self, iprot):
13836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13838 
      return
13839 
    iprot.readStructBegin()
13840 
    while True:
13841 
      (fname, ftype, fid) = iprot.readFieldBegin()
13842 
      if ftype == TType.STOP:
13843 
        break
13844 
      if fid == 0:
13845 
        if ftype == TType.LIST:
13846 
          self.success = []
7438 amit.gupta 13847 
          (_etype247, _size244) = iprot.readListBegin()
13848 
          for _i248 in xrange(_size244):
13849 
            _elem249 = SourceItemPricing()
13850 
            _elem249.read(iprot)
13851 
            self.success.append(_elem249)
5944 mandeep.dh 13852 
          iprot.readListEnd()
13853 
        else:
13854 
          iprot.skip(ftype)
13855 
      elif fid == 1:
13856 
        if ftype == TType.STRUCT:
13857 
          self.cex = CatalogServiceException()
13858 
          self.cex.read(iprot)
13859 
        else:
13860 
          iprot.skip(ftype)
13861 
      else:
13862 
        iprot.skip(ftype)
13863 
      iprot.readFieldEnd()
13864 
    iprot.readStructEnd()
13865 
 
13866 
  def write(self, oprot):
13867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13869 
      return
13870 
    oprot.writeStructBegin('getAllSourcePricing_result')
13871 
    if self.success is not None:
13872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13874 
      for iter250 in self.success:
13875 
        iter250.write(oprot)
5944 mandeep.dh 13876 
      oprot.writeListEnd()
13877 
      oprot.writeFieldEnd()
13878 
    if self.cex is not None:
13879 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13880 
      self.cex.write(oprot)
13881 
      oprot.writeFieldEnd()
13882 
    oprot.writeFieldStop()
13883 
    oprot.writeStructEnd()
13884 
 
13885 
  def validate(self):
13886 
    return
13887 
 
13888 
 
13889 
  def __repr__(self):
13890 
    L = ['%s=%r' % (key, value)
13891 
      for key, value in self.__dict__.iteritems()]
13892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13893 
 
13894 
  def __eq__(self, other):
13895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13896 
 
13897 
  def __ne__(self, other):
13898 
    return not (self == other)
13899 
 
13900 
class getItemForSource_args:
13901 
  """
13902 
  Attributes:
13903 
   - item_id
13904 
   - sourceId
13905 
  """
13906 
 
13907 
  thrift_spec = (
13908 
    None, # 0
13909 
    (1, TType.I64, 'item_id', None, None, ), # 1
13910 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13911 
  )
13912 
 
13913 
  def __init__(self, item_id=None, sourceId=None,):
13914 
    self.item_id = item_id
13915 
    self.sourceId = sourceId
13916 
 
13917 
  def read(self, iprot):
13918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13920 
      return
13921 
    iprot.readStructBegin()
13922 
    while True:
13923 
      (fname, ftype, fid) = iprot.readFieldBegin()
13924 
      if ftype == TType.STOP:
13925 
        break
13926 
      if fid == 1:
13927 
        if ftype == TType.I64:
13928 
          self.item_id = iprot.readI64();
13929 
        else:
13930 
          iprot.skip(ftype)
13931 
      elif fid == 2:
13932 
        if ftype == TType.I64:
13933 
          self.sourceId = iprot.readI64();
13934 
        else:
13935 
          iprot.skip(ftype)
13936 
      else:
13937 
        iprot.skip(ftype)
13938 
      iprot.readFieldEnd()
13939 
    iprot.readStructEnd()
13940 
 
13941 
  def write(self, oprot):
13942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13944 
      return
13945 
    oprot.writeStructBegin('getItemForSource_args')
13946 
    if self.item_id is not None:
13947 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13948 
      oprot.writeI64(self.item_id)
13949 
      oprot.writeFieldEnd()
13950 
    if self.sourceId is not None:
13951 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13952 
      oprot.writeI64(self.sourceId)
13953 
      oprot.writeFieldEnd()
13954 
    oprot.writeFieldStop()
13955 
    oprot.writeStructEnd()
13956 
 
13957 
  def validate(self):
13958 
    return
13959 
 
13960 
 
13961 
  def __repr__(self):
13962 
    L = ['%s=%r' % (key, value)
13963 
      for key, value in self.__dict__.iteritems()]
13964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13965 
 
13966 
  def __eq__(self, other):
13967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13968 
 
13969 
  def __ne__(self, other):
13970 
    return not (self == other)
13971 
 
13972 
class getItemForSource_result:
13973 
  """
13974 
  Attributes:
13975 
   - success
13976 
   - cex
13977 
  """
13978 
 
13979 
  thrift_spec = (
13980 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13981 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13982 
  )
13983 
 
13984 
  def __init__(self, success=None, cex=None,):
13985 
    self.success = success
13986 
    self.cex = cex
13987 
 
13988 
  def read(self, iprot):
13989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13991 
      return
13992 
    iprot.readStructBegin()
13993 
    while True:
13994 
      (fname, ftype, fid) = iprot.readFieldBegin()
13995 
      if ftype == TType.STOP:
13996 
        break
13997 
      if fid == 0:
13998 
        if ftype == TType.STRUCT:
13999 
          self.success = Item()
14000 
          self.success.read(iprot)
14001 
        else:
14002 
          iprot.skip(ftype)
14003 
      elif fid == 1:
14004 
        if ftype == TType.STRUCT:
14005 
          self.cex = CatalogServiceException()
14006 
          self.cex.read(iprot)
14007 
        else:
14008 
          iprot.skip(ftype)
14009 
      else:
14010 
        iprot.skip(ftype)
14011 
      iprot.readFieldEnd()
14012 
    iprot.readStructEnd()
14013 
 
14014 
  def write(self, oprot):
14015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14017 
      return
14018 
    oprot.writeStructBegin('getItemForSource_result')
14019 
    if self.success is not None:
14020 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14021 
      self.success.write(oprot)
14022 
      oprot.writeFieldEnd()
14023 
    if self.cex is not None:
14024 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14025 
      self.cex.write(oprot)
14026 
      oprot.writeFieldEnd()
14027 
    oprot.writeFieldStop()
14028 
    oprot.writeStructEnd()
14029 
 
14030 
  def validate(self):
14031 
    return
14032 
 
14033 
 
14034 
  def __repr__(self):
14035 
    L = ['%s=%r' % (key, value)
14036 
      for key, value in self.__dict__.iteritems()]
14037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14038 
 
14039 
  def __eq__(self, other):
14040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14041 
 
14042 
  def __ne__(self, other):
14043 
    return not (self == other)
14044 
 
14045 
class searchItemsInRange_args:
14046 
  """
14047 
  Attributes:
14048 
   - searchTerms
14049 
   - offset
14050 
   - limit
14051 
  """
14052 
 
14053 
  thrift_spec = (
14054 
    None, # 0
14055 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14056 
    (2, TType.I64, 'offset', None, None, ), # 2
14057 
    (3, TType.I64, 'limit', None, None, ), # 3
14058 
  )
14059 
 
14060 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
14061 
    self.searchTerms = searchTerms
14062 
    self.offset = offset
14063 
    self.limit = limit
14064 
 
14065 
  def read(self, iprot):
14066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14068 
      return
14069 
    iprot.readStructBegin()
14070 
    while True:
14071 
      (fname, ftype, fid) = iprot.readFieldBegin()
14072 
      if ftype == TType.STOP:
14073 
        break
14074 
      if fid == 1:
14075 
        if ftype == TType.LIST:
14076 
          self.searchTerms = []
7438 amit.gupta 14077 
          (_etype254, _size251) = iprot.readListBegin()
14078 
          for _i255 in xrange(_size251):
14079 
            _elem256 = iprot.readString();
14080 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 14081 
          iprot.readListEnd()
14082 
        else:
14083 
          iprot.skip(ftype)
14084 
      elif fid == 2:
14085 
        if ftype == TType.I64:
14086 
          self.offset = iprot.readI64();
14087 
        else:
14088 
          iprot.skip(ftype)
14089 
      elif fid == 3:
14090 
        if ftype == TType.I64:
14091 
          self.limit = iprot.readI64();
14092 
        else:
14093 
          iprot.skip(ftype)
14094 
      else:
14095 
        iprot.skip(ftype)
14096 
      iprot.readFieldEnd()
14097 
    iprot.readStructEnd()
14098 
 
14099 
  def write(self, oprot):
14100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14102 
      return
14103 
    oprot.writeStructBegin('searchItemsInRange_args')
14104 
    if self.searchTerms is not None:
14105 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14106 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14107 
      for iter257 in self.searchTerms:
14108 
        oprot.writeString(iter257)
5944 mandeep.dh 14109 
      oprot.writeListEnd()
14110 
      oprot.writeFieldEnd()
14111 
    if self.offset is not None:
14112 
      oprot.writeFieldBegin('offset', TType.I64, 2)
14113 
      oprot.writeI64(self.offset)
14114 
      oprot.writeFieldEnd()
14115 
    if self.limit is not None:
14116 
      oprot.writeFieldBegin('limit', TType.I64, 3)
14117 
      oprot.writeI64(self.limit)
14118 
      oprot.writeFieldEnd()
14119 
    oprot.writeFieldStop()
14120 
    oprot.writeStructEnd()
14121 
 
14122 
  def validate(self):
14123 
    return
14124 
 
14125 
 
14126 
  def __repr__(self):
14127 
    L = ['%s=%r' % (key, value)
14128 
      for key, value in self.__dict__.iteritems()]
14129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14130 
 
14131 
  def __eq__(self, other):
14132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14133 
 
14134 
  def __ne__(self, other):
14135 
    return not (self == other)
14136 
 
14137 
class searchItemsInRange_result:
14138 
  """
14139 
  Attributes:
14140 
   - success
14141 
  """
14142 
 
14143 
  thrift_spec = (
14144 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14145 
  )
14146 
 
14147 
  def __init__(self, success=None,):
14148 
    self.success = success
14149 
 
14150 
  def read(self, iprot):
14151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14153 
      return
14154 
    iprot.readStructBegin()
14155 
    while True:
14156 
      (fname, ftype, fid) = iprot.readFieldBegin()
14157 
      if ftype == TType.STOP:
14158 
        break
14159 
      if fid == 0:
14160 
        if ftype == TType.LIST:
14161 
          self.success = []
7438 amit.gupta 14162 
          (_etype261, _size258) = iprot.readListBegin()
14163 
          for _i262 in xrange(_size258):
14164 
            _elem263 = Item()
14165 
            _elem263.read(iprot)
14166 
            self.success.append(_elem263)
5944 mandeep.dh 14167 
          iprot.readListEnd()
14168 
        else:
14169 
          iprot.skip(ftype)
14170 
      else:
14171 
        iprot.skip(ftype)
14172 
      iprot.readFieldEnd()
14173 
    iprot.readStructEnd()
14174 
 
14175 
  def write(self, oprot):
14176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14178 
      return
14179 
    oprot.writeStructBegin('searchItemsInRange_result')
14180 
    if self.success is not None:
14181 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14182 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14183 
      for iter264 in self.success:
14184 
        iter264.write(oprot)
5944 mandeep.dh 14185 
      oprot.writeListEnd()
14186 
      oprot.writeFieldEnd()
14187 
    oprot.writeFieldStop()
14188 
    oprot.writeStructEnd()
14189 
 
14190 
  def validate(self):
14191 
    return
14192 
 
14193 
 
14194 
  def __repr__(self):
14195 
    L = ['%s=%r' % (key, value)
14196 
      for key, value in self.__dict__.iteritems()]
14197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14198 
 
14199 
  def __eq__(self, other):
14200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14201 
 
14202 
  def __ne__(self, other):
14203 
    return not (self == other)
14204 
 
14205 
class getSearchResultCount_args:
14206 
  """
14207 
  Attributes:
14208 
   - searchTerms
14209 
  """
14210 
 
14211 
  thrift_spec = (
14212 
    None, # 0
14213 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14214 
  )
14215 
 
14216 
  def __init__(self, searchTerms=None,):
14217 
    self.searchTerms = searchTerms
14218 
 
14219 
  def read(self, iprot):
14220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14222 
      return
14223 
    iprot.readStructBegin()
14224 
    while True:
14225 
      (fname, ftype, fid) = iprot.readFieldBegin()
14226 
      if ftype == TType.STOP:
14227 
        break
14228 
      if fid == 1:
14229 
        if ftype == TType.LIST:
14230 
          self.searchTerms = []
7438 amit.gupta 14231 
          (_etype268, _size265) = iprot.readListBegin()
14232 
          for _i269 in xrange(_size265):
14233 
            _elem270 = iprot.readString();
14234 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14235 
          iprot.readListEnd()
14236 
        else:
14237 
          iprot.skip(ftype)
14238 
      else:
14239 
        iprot.skip(ftype)
14240 
      iprot.readFieldEnd()
14241 
    iprot.readStructEnd()
14242 
 
14243 
  def write(self, oprot):
14244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14246 
      return
14247 
    oprot.writeStructBegin('getSearchResultCount_args')
14248 
    if self.searchTerms is not None:
14249 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14250 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14251 
      for iter271 in self.searchTerms:
14252 
        oprot.writeString(iter271)
5944 mandeep.dh 14253 
      oprot.writeListEnd()
14254 
      oprot.writeFieldEnd()
14255 
    oprot.writeFieldStop()
14256 
    oprot.writeStructEnd()
14257 
 
14258 
  def validate(self):
14259 
    return
14260 
 
14261 
 
14262 
  def __repr__(self):
14263 
    L = ['%s=%r' % (key, value)
14264 
      for key, value in self.__dict__.iteritems()]
14265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14266 
 
14267 
  def __eq__(self, other):
14268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14269 
 
14270 
  def __ne__(self, other):
14271 
    return not (self == other)
14272 
 
14273 
class getSearchResultCount_result:
14274 
  """
14275 
  Attributes:
14276 
   - success
14277 
  """
14278 
 
14279 
  thrift_spec = (
14280 
    (0, TType.I32, 'success', None, None, ), # 0
14281 
  )
14282 
 
14283 
  def __init__(self, success=None,):
14284 
    self.success = success
14285 
 
14286 
  def read(self, iprot):
14287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14289 
      return
14290 
    iprot.readStructBegin()
14291 
    while True:
14292 
      (fname, ftype, fid) = iprot.readFieldBegin()
14293 
      if ftype == TType.STOP:
14294 
        break
14295 
      if fid == 0:
14296 
        if ftype == TType.I32:
14297 
          self.success = iprot.readI32();
14298 
        else:
14299 
          iprot.skip(ftype)
14300 
      else:
14301 
        iprot.skip(ftype)
14302 
      iprot.readFieldEnd()
14303 
    iprot.readStructEnd()
14304 
 
14305 
  def write(self, oprot):
14306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14308 
      return
14309 
    oprot.writeStructBegin('getSearchResultCount_result')
14310 
    if self.success is not None:
14311 
      oprot.writeFieldBegin('success', TType.I32, 0)
14312 
      oprot.writeI32(self.success)
14313 
      oprot.writeFieldEnd()
14314 
    oprot.writeFieldStop()
14315 
    oprot.writeStructEnd()
14316 
 
14317 
  def validate(self):
14318 
    return
14319 
 
14320 
 
14321 
  def __repr__(self):
14322 
    L = ['%s=%r' % (key, value)
14323 
      for key, value in self.__dict__.iteritems()]
14324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14325 
 
14326 
  def __eq__(self, other):
14327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14328 
 
14329 
  def __ne__(self, other):
14330 
    return not (self == other)
14331 
 
14332 
class getProductNotifications_args:
14333 
  """
14334 
  Attributes:
14335 
   - startDateTime
14336 
  """
14337 
 
14338 
  thrift_spec = (
14339 
    None, # 0
14340 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14341 
  )
14342 
 
14343 
  def __init__(self, startDateTime=None,):
14344 
    self.startDateTime = startDateTime
14345 
 
14346 
  def read(self, iprot):
14347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14349 
      return
14350 
    iprot.readStructBegin()
14351 
    while True:
14352 
      (fname, ftype, fid) = iprot.readFieldBegin()
14353 
      if ftype == TType.STOP:
14354 
        break
14355 
      if fid == 1:
14356 
        if ftype == TType.I64:
14357 
          self.startDateTime = iprot.readI64();
14358 
        else:
14359 
          iprot.skip(ftype)
14360 
      else:
14361 
        iprot.skip(ftype)
14362 
      iprot.readFieldEnd()
14363 
    iprot.readStructEnd()
14364 
 
14365 
  def write(self, oprot):
14366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14368 
      return
14369 
    oprot.writeStructBegin('getProductNotifications_args')
14370 
    if self.startDateTime is not None:
14371 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14372 
      oprot.writeI64(self.startDateTime)
14373 
      oprot.writeFieldEnd()
14374 
    oprot.writeFieldStop()
14375 
    oprot.writeStructEnd()
14376 
 
14377 
  def validate(self):
14378 
    return
14379 
 
14380 
 
14381 
  def __repr__(self):
14382 
    L = ['%s=%r' % (key, value)
14383 
      for key, value in self.__dict__.iteritems()]
14384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14385 
 
14386 
  def __eq__(self, other):
14387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14388 
 
14389 
  def __ne__(self, other):
14390 
    return not (self == other)
14391 
 
14392 
class getProductNotifications_result:
14393 
  """
14394 
  Attributes:
14395 
   - success
14396 
  """
14397 
 
14398 
  thrift_spec = (
14399 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14400 
  )
14401 
 
14402 
  def __init__(self, success=None,):
14403 
    self.success = success
14404 
 
14405 
  def read(self, iprot):
14406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14408 
      return
14409 
    iprot.readStructBegin()
14410 
    while True:
14411 
      (fname, ftype, fid) = iprot.readFieldBegin()
14412 
      if ftype == TType.STOP:
14413 
        break
14414 
      if fid == 0:
14415 
        if ftype == TType.LIST:
14416 
          self.success = []
7438 amit.gupta 14417 
          (_etype275, _size272) = iprot.readListBegin()
14418 
          for _i276 in xrange(_size272):
14419 
            _elem277 = ProductNotificationRequest()
14420 
            _elem277.read(iprot)
14421 
            self.success.append(_elem277)
5944 mandeep.dh 14422 
          iprot.readListEnd()
14423 
        else:
14424 
          iprot.skip(ftype)
14425 
      else:
14426 
        iprot.skip(ftype)
14427 
      iprot.readFieldEnd()
14428 
    iprot.readStructEnd()
14429 
 
14430 
  def write(self, oprot):
14431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14433 
      return
14434 
    oprot.writeStructBegin('getProductNotifications_result')
14435 
    if self.success is not None:
14436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14438 
      for iter278 in self.success:
14439 
        iter278.write(oprot)
5944 mandeep.dh 14440 
      oprot.writeListEnd()
14441 
      oprot.writeFieldEnd()
14442 
    oprot.writeFieldStop()
14443 
    oprot.writeStructEnd()
14444 
 
14445 
  def validate(self):
14446 
    return
14447 
 
14448 
 
14449 
  def __repr__(self):
14450 
    L = ['%s=%r' % (key, value)
14451 
      for key, value in self.__dict__.iteritems()]
14452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14453 
 
14454 
  def __eq__(self, other):
14455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14456 
 
14457 
  def __ne__(self, other):
14458 
    return not (self == other)
14459 
 
14460 
class getProductNotificationRequestCount_args:
14461 
  """
14462 
  Attributes:
14463 
   - startDateTime
7897 amar.kumar 14464 
   - categoryId
5944 mandeep.dh 14465 
  """
14466 
 
14467 
  thrift_spec = (
14468 
    None, # 0
14469 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 14470 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 14471 
  )
14472 
 
7897 amar.kumar 14473 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 14474 
    self.startDateTime = startDateTime
7897 amar.kumar 14475 
    self.categoryId = categoryId
5944 mandeep.dh 14476 
 
14477 
  def read(self, iprot):
14478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14480 
      return
14481 
    iprot.readStructBegin()
14482 
    while True:
14483 
      (fname, ftype, fid) = iprot.readFieldBegin()
14484 
      if ftype == TType.STOP:
14485 
        break
14486 
      if fid == 1:
14487 
        if ftype == TType.I64:
14488 
          self.startDateTime = iprot.readI64();
14489 
        else:
14490 
          iprot.skip(ftype)
7897 amar.kumar 14491 
      elif fid == 2:
14492 
        if ftype == TType.I64:
14493 
          self.categoryId = iprot.readI64();
14494 
        else:
14495 
          iprot.skip(ftype)
5944 mandeep.dh 14496 
      else:
14497 
        iprot.skip(ftype)
14498 
      iprot.readFieldEnd()
14499 
    iprot.readStructEnd()
14500 
 
14501 
  def write(self, oprot):
14502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14504 
      return
14505 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14506 
    if self.startDateTime is not None:
14507 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14508 
      oprot.writeI64(self.startDateTime)
14509 
      oprot.writeFieldEnd()
7897 amar.kumar 14510 
    if self.categoryId is not None:
14511 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
14512 
      oprot.writeI64(self.categoryId)
14513 
      oprot.writeFieldEnd()
5944 mandeep.dh 14514 
    oprot.writeFieldStop()
14515 
    oprot.writeStructEnd()
14516 
 
14517 
  def validate(self):
14518 
    return
14519 
 
14520 
 
14521 
  def __repr__(self):
14522 
    L = ['%s=%r' % (key, value)
14523 
      for key, value in self.__dict__.iteritems()]
14524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14525 
 
14526 
  def __eq__(self, other):
14527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14528 
 
14529 
  def __ne__(self, other):
14530 
    return not (self == other)
14531 
 
14532 
class getProductNotificationRequestCount_result:
14533 
  """
14534 
  Attributes:
14535 
   - success
14536 
  """
14537 
 
14538 
  thrift_spec = (
14539 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14540 
  )
14541 
 
14542 
  def __init__(self, success=None,):
14543 
    self.success = success
14544 
 
14545 
  def read(self, iprot):
14546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14548 
      return
14549 
    iprot.readStructBegin()
14550 
    while True:
14551 
      (fname, ftype, fid) = iprot.readFieldBegin()
14552 
      if ftype == TType.STOP:
14553 
        break
14554 
      if fid == 0:
14555 
        if ftype == TType.LIST:
14556 
          self.success = []
7438 amit.gupta 14557 
          (_etype282, _size279) = iprot.readListBegin()
14558 
          for _i283 in xrange(_size279):
14559 
            _elem284 = ProductNotificationRequestCount()
14560 
            _elem284.read(iprot)
14561 
            self.success.append(_elem284)
5944 mandeep.dh 14562 
          iprot.readListEnd()
14563 
        else:
14564 
          iprot.skip(ftype)
14565 
      else:
14566 
        iprot.skip(ftype)
14567 
      iprot.readFieldEnd()
14568 
    iprot.readStructEnd()
14569 
 
14570 
  def write(self, oprot):
14571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14573 
      return
14574 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14575 
    if self.success is not None:
14576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14578 
      for iter285 in self.success:
14579 
        iter285.write(oprot)
5944 mandeep.dh 14580 
      oprot.writeListEnd()
14581 
      oprot.writeFieldEnd()
14582 
    oprot.writeFieldStop()
14583 
    oprot.writeStructEnd()
14584 
 
14585 
  def validate(self):
14586 
    return
14587 
 
14588 
 
14589 
  def __repr__(self):
14590 
    L = ['%s=%r' % (key, value)
14591 
      for key, value in self.__dict__.iteritems()]
14592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14593 
 
14594 
  def __eq__(self, other):
14595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14596 
 
14597 
  def __ne__(self, other):
14598 
    return not (self == other)
14599 
 
14600 
class addAuthorizationLog_args:
14601 
  """
14602 
  Attributes:
14603 
   - itemId
14604 
   - username
14605 
   - reason
14606 
  """
14607 
 
14608 
  thrift_spec = (
14609 
    None, # 0
14610 
    (1, TType.I64, 'itemId', None, None, ), # 1
14611 
    (2, TType.STRING, 'username', None, None, ), # 2
14612 
    (3, TType.STRING, 'reason', None, None, ), # 3
14613 
  )
14614 
 
14615 
  def __init__(self, itemId=None, username=None, reason=None,):
14616 
    self.itemId = itemId
14617 
    self.username = username
14618 
    self.reason = reason
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 == 1:
14630 
        if ftype == TType.I64:
14631 
          self.itemId = iprot.readI64();
14632 
        else:
14633 
          iprot.skip(ftype)
14634 
      elif fid == 2:
14635 
        if ftype == TType.STRING:
14636 
          self.username = iprot.readString();
14637 
        else:
14638 
          iprot.skip(ftype)
14639 
      elif fid == 3:
14640 
        if ftype == TType.STRING:
14641 
          self.reason = iprot.readString();
14642 
        else:
14643 
          iprot.skip(ftype)
14644 
      else:
14645 
        iprot.skip(ftype)
14646 
      iprot.readFieldEnd()
14647 
    iprot.readStructEnd()
14648 
 
14649 
  def write(self, oprot):
14650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14652 
      return
14653 
    oprot.writeStructBegin('addAuthorizationLog_args')
14654 
    if self.itemId is not None:
14655 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14656 
      oprot.writeI64(self.itemId)
14657 
      oprot.writeFieldEnd()
14658 
    if self.username is not None:
14659 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14660 
      oprot.writeString(self.username)
14661 
      oprot.writeFieldEnd()
14662 
    if self.reason is not None:
14663 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14664 
      oprot.writeString(self.reason)
14665 
      oprot.writeFieldEnd()
14666 
    oprot.writeFieldStop()
14667 
    oprot.writeStructEnd()
14668 
 
14669 
  def validate(self):
14670 
    return
14671 
 
14672 
 
14673 
  def __repr__(self):
14674 
    L = ['%s=%r' % (key, value)
14675 
      for key, value in self.__dict__.iteritems()]
14676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14677 
 
14678 
  def __eq__(self, other):
14679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14680 
 
14681 
  def __ne__(self, other):
14682 
    return not (self == other)
14683 
 
14684 
class addAuthorizationLog_result:
14685 
  """
14686 
  Attributes:
14687 
   - success
14688 
   - cex
14689 
  """
14690 
 
14691 
  thrift_spec = (
14692 
    (0, TType.BOOL, 'success', None, None, ), # 0
14693 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14694 
  )
14695 
 
14696 
  def __init__(self, success=None, cex=None,):
14697 
    self.success = success
14698 
    self.cex = cex
14699 
 
14700 
  def read(self, iprot):
14701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14703 
      return
14704 
    iprot.readStructBegin()
14705 
    while True:
14706 
      (fname, ftype, fid) = iprot.readFieldBegin()
14707 
      if ftype == TType.STOP:
14708 
        break
14709 
      if fid == 0:
14710 
        if ftype == TType.BOOL:
14711 
          self.success = iprot.readBool();
14712 
        else:
14713 
          iprot.skip(ftype)
14714 
      elif fid == 1:
14715 
        if ftype == TType.STRUCT:
14716 
          self.cex = CatalogServiceException()
14717 
          self.cex.read(iprot)
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('addAuthorizationLog_result')
14730 
    if self.success is not None:
14731 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14732 
      oprot.writeBool(self.success)
14733 
      oprot.writeFieldEnd()
14734 
    if self.cex is not None:
14735 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14736 
      self.cex.write(oprot)
14737 
      oprot.writeFieldEnd()
14738 
    oprot.writeFieldStop()
14739 
    oprot.writeStructEnd()
14740 
 
14741 
  def validate(self):
14742 
    return
14743 
 
14744 
 
14745 
  def __repr__(self):
14746 
    L = ['%s=%r' % (key, value)
14747 
      for key, value in self.__dict__.iteritems()]
14748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14749 
 
14750 
  def __eq__(self, other):
14751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14752 
 
14753 
  def __ne__(self, other):
14754 
    return not (self == other)
14755 
 
14756 
class addupdateVoucherForItem_args:
14757 
  """
14758 
  Attributes:
14759 
   - catalog_item_id
14760 
   - voucherType
14761 
   - voucherAmount
14762 
  """
14763 
 
14764 
  thrift_spec = (
14765 
    None, # 0
14766 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14767 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14768 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14769 
  )
14770 
 
14771 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14772 
    self.catalog_item_id = catalog_item_id
14773 
    self.voucherType = voucherType
14774 
    self.voucherAmount = voucherAmount
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 == 1:
14786 
        if ftype == TType.I64:
14787 
          self.catalog_item_id = iprot.readI64();
14788 
        else:
14789 
          iprot.skip(ftype)
14790 
      elif fid == 2:
14791 
        if ftype == TType.I64:
14792 
          self.voucherType = iprot.readI64();
14793 
        else:
14794 
          iprot.skip(ftype)
14795 
      elif fid == 3:
14796 
        if ftype == TType.I64:
14797 
          self.voucherAmount = iprot.readI64();
14798 
        else:
14799 
          iprot.skip(ftype)
14800 
      else:
14801 
        iprot.skip(ftype)
14802 
      iprot.readFieldEnd()
14803 
    iprot.readStructEnd()
14804 
 
14805 
  def write(self, oprot):
14806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14808 
      return
14809 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14810 
    if self.catalog_item_id is not None:
14811 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14812 
      oprot.writeI64(self.catalog_item_id)
14813 
      oprot.writeFieldEnd()
14814 
    if self.voucherType is not None:
14815 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14816 
      oprot.writeI64(self.voucherType)
14817 
      oprot.writeFieldEnd()
14818 
    if self.voucherAmount is not None:
14819 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14820 
      oprot.writeI64(self.voucherAmount)
14821 
      oprot.writeFieldEnd()
14822 
    oprot.writeFieldStop()
14823 
    oprot.writeStructEnd()
14824 
 
14825 
  def validate(self):
14826 
    return
14827 
 
14828 
 
14829 
  def __repr__(self):
14830 
    L = ['%s=%r' % (key, value)
14831 
      for key, value in self.__dict__.iteritems()]
14832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14833 
 
14834 
  def __eq__(self, other):
14835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14836 
 
14837 
  def __ne__(self, other):
14838 
    return not (self == other)
14839 
 
14840 
class addupdateVoucherForItem_result:
14841 
  """
14842 
  Attributes:
14843 
   - success
14844 
   - cex
14845 
  """
14846 
 
14847 
  thrift_spec = (
14848 
    (0, TType.BOOL, 'success', None, None, ), # 0
14849 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14850 
  )
14851 
 
14852 
  def __init__(self, success=None, cex=None,):
14853 
    self.success = success
14854 
    self.cex = cex
14855 
 
14856 
  def read(self, iprot):
14857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14859 
      return
14860 
    iprot.readStructBegin()
14861 
    while True:
14862 
      (fname, ftype, fid) = iprot.readFieldBegin()
14863 
      if ftype == TType.STOP:
14864 
        break
14865 
      if fid == 0:
14866 
        if ftype == TType.BOOL:
14867 
          self.success = iprot.readBool();
14868 
        else:
14869 
          iprot.skip(ftype)
14870 
      elif fid == 1:
14871 
        if ftype == TType.STRUCT:
14872 
          self.cex = CatalogServiceException()
14873 
          self.cex.read(iprot)
14874 
        else:
14875 
          iprot.skip(ftype)
14876 
      else:
14877 
        iprot.skip(ftype)
14878 
      iprot.readFieldEnd()
14879 
    iprot.readStructEnd()
14880 
 
14881 
  def write(self, oprot):
14882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14884 
      return
14885 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14886 
    if self.success is not None:
14887 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14888 
      oprot.writeBool(self.success)
14889 
      oprot.writeFieldEnd()
14890 
    if self.cex is not None:
14891 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14892 
      self.cex.write(oprot)
14893 
      oprot.writeFieldEnd()
14894 
    oprot.writeFieldStop()
14895 
    oprot.writeStructEnd()
14896 
 
14897 
  def validate(self):
14898 
    return
14899 
 
14900 
 
14901 
  def __repr__(self):
14902 
    L = ['%s=%r' % (key, value)
14903 
      for key, value in self.__dict__.iteritems()]
14904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14905 
 
14906 
  def __eq__(self, other):
14907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14908 
 
14909 
  def __ne__(self, other):
14910 
    return not (self == other)
14911 
 
14912 
class deleteVoucherForItem_args:
14913 
  """
14914 
  Attributes:
14915 
   - catalog_item_id
14916 
   - voucherType
14917 
  """
14918 
 
14919 
  thrift_spec = (
14920 
    None, # 0
14921 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14922 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14923 
  )
14924 
 
14925 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14926 
    self.catalog_item_id = catalog_item_id
14927 
    self.voucherType = voucherType
14928 
 
14929 
  def read(self, iprot):
14930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14932 
      return
14933 
    iprot.readStructBegin()
14934 
    while True:
14935 
      (fname, ftype, fid) = iprot.readFieldBegin()
14936 
      if ftype == TType.STOP:
14937 
        break
14938 
      if fid == 1:
14939 
        if ftype == TType.I64:
14940 
          self.catalog_item_id = iprot.readI64();
14941 
        else:
14942 
          iprot.skip(ftype)
14943 
      elif fid == 2:
14944 
        if ftype == TType.I64:
14945 
          self.voucherType = iprot.readI64();
14946 
        else:
14947 
          iprot.skip(ftype)
14948 
      else:
14949 
        iprot.skip(ftype)
14950 
      iprot.readFieldEnd()
14951 
    iprot.readStructEnd()
14952 
 
14953 
  def write(self, oprot):
14954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14956 
      return
14957 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14958 
    if self.catalog_item_id is not None:
14959 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14960 
      oprot.writeI64(self.catalog_item_id)
14961 
      oprot.writeFieldEnd()
14962 
    if self.voucherType is not None:
14963 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14964 
      oprot.writeI64(self.voucherType)
14965 
      oprot.writeFieldEnd()
14966 
    oprot.writeFieldStop()
14967 
    oprot.writeStructEnd()
14968 
 
14969 
  def validate(self):
14970 
    return
14971 
 
14972 
 
14973 
  def __repr__(self):
14974 
    L = ['%s=%r' % (key, value)
14975 
      for key, value in self.__dict__.iteritems()]
14976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14977 
 
14978 
  def __eq__(self, other):
14979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14980 
 
14981 
  def __ne__(self, other):
14982 
    return not (self == other)
14983 
 
14984 
class deleteVoucherForItem_result:
14985 
  """
14986 
  Attributes:
14987 
   - success
14988 
   - cex
14989 
  """
14990 
 
14991 
  thrift_spec = (
14992 
    (0, TType.BOOL, 'success', None, None, ), # 0
14993 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14994 
  )
14995 
 
14996 
  def __init__(self, success=None, cex=None,):
14997 
    self.success = success
14998 
    self.cex = cex
14999 
 
15000 
  def read(self, iprot):
15001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15003 
      return
15004 
    iprot.readStructBegin()
15005 
    while True:
15006 
      (fname, ftype, fid) = iprot.readFieldBegin()
15007 
      if ftype == TType.STOP:
15008 
        break
15009 
      if fid == 0:
15010 
        if ftype == TType.BOOL:
15011 
          self.success = iprot.readBool();
15012 
        else:
15013 
          iprot.skip(ftype)
15014 
      elif fid == 1:
15015 
        if ftype == TType.STRUCT:
15016 
          self.cex = CatalogServiceException()
15017 
          self.cex.read(iprot)
15018 
        else:
15019 
          iprot.skip(ftype)
15020 
      else:
15021 
        iprot.skip(ftype)
15022 
      iprot.readFieldEnd()
15023 
    iprot.readStructEnd()
15024 
 
15025 
  def write(self, oprot):
15026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15028 
      return
15029 
    oprot.writeStructBegin('deleteVoucherForItem_result')
15030 
    if self.success is not None:
15031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15032 
      oprot.writeBool(self.success)
15033 
      oprot.writeFieldEnd()
15034 
    if self.cex is not None:
15035 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15036 
      self.cex.write(oprot)
15037 
      oprot.writeFieldEnd()
15038 
    oprot.writeFieldStop()
15039 
    oprot.writeStructEnd()
15040 
 
15041 
  def validate(self):
15042 
    return
15043 
 
15044 
 
15045 
  def __repr__(self):
15046 
    L = ['%s=%r' % (key, value)
15047 
      for key, value in self.__dict__.iteritems()]
15048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15049 
 
15050 
  def __eq__(self, other):
15051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15052 
 
15053 
  def __ne__(self, other):
15054 
    return not (self == other)
15055 
 
15056 
class getVoucherAmount_args:
15057 
  """
15058 
  Attributes:
15059 
   - itemId
15060 
   - voucherType
15061 
  """
15062 
 
15063 
  thrift_spec = (
15064 
    None, # 0
15065 
    (1, TType.I64, 'itemId', None, None, ), # 1
15066 
    (2, TType.I64, 'voucherType', None, None, ), # 2
15067 
  )
15068 
 
15069 
  def __init__(self, itemId=None, voucherType=None,):
15070 
    self.itemId = itemId
15071 
    self.voucherType = voucherType
15072 
 
15073 
  def read(self, iprot):
15074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15076 
      return
15077 
    iprot.readStructBegin()
15078 
    while True:
15079 
      (fname, ftype, fid) = iprot.readFieldBegin()
15080 
      if ftype == TType.STOP:
15081 
        break
15082 
      if fid == 1:
15083 
        if ftype == TType.I64:
15084 
          self.itemId = iprot.readI64();
15085 
        else:
15086 
          iprot.skip(ftype)
15087 
      elif fid == 2:
15088 
        if ftype == TType.I64:
15089 
          self.voucherType = iprot.readI64();
15090 
        else:
15091 
          iprot.skip(ftype)
15092 
      else:
15093 
        iprot.skip(ftype)
15094 
      iprot.readFieldEnd()
15095 
    iprot.readStructEnd()
15096 
 
15097 
  def write(self, oprot):
15098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15100 
      return
15101 
    oprot.writeStructBegin('getVoucherAmount_args')
15102 
    if self.itemId is not None:
15103 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15104 
      oprot.writeI64(self.itemId)
15105 
      oprot.writeFieldEnd()
15106 
    if self.voucherType is not None:
15107 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15108 
      oprot.writeI64(self.voucherType)
15109 
      oprot.writeFieldEnd()
15110 
    oprot.writeFieldStop()
15111 
    oprot.writeStructEnd()
15112 
 
15113 
  def validate(self):
15114 
    return
15115 
 
15116 
 
15117 
  def __repr__(self):
15118 
    L = ['%s=%r' % (key, value)
15119 
      for key, value in self.__dict__.iteritems()]
15120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15121 
 
15122 
  def __eq__(self, other):
15123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15124 
 
15125 
  def __ne__(self, other):
15126 
    return not (self == other)
15127 
 
15128 
class getVoucherAmount_result:
15129 
  """
15130 
  Attributes:
15131 
   - success
15132 
  """
15133 
 
15134 
  thrift_spec = (
15135 
    (0, TType.I64, 'success', None, None, ), # 0
15136 
  )
15137 
 
15138 
  def __init__(self, success=None,):
15139 
    self.success = success
15140 
 
15141 
  def read(self, iprot):
15142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15144 
      return
15145 
    iprot.readStructBegin()
15146 
    while True:
15147 
      (fname, ftype, fid) = iprot.readFieldBegin()
15148 
      if ftype == TType.STOP:
15149 
        break
15150 
      if fid == 0:
15151 
        if ftype == TType.I64:
15152 
          self.success = iprot.readI64();
15153 
        else:
15154 
          iprot.skip(ftype)
15155 
      else:
15156 
        iprot.skip(ftype)
15157 
      iprot.readFieldEnd()
15158 
    iprot.readStructEnd()
15159 
 
15160 
  def write(self, oprot):
15161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15163 
      return
15164 
    oprot.writeStructBegin('getVoucherAmount_result')
15165 
    if self.success is not None:
15166 
      oprot.writeFieldBegin('success', TType.I64, 0)
15167 
      oprot.writeI64(self.success)
15168 
      oprot.writeFieldEnd()
15169 
    oprot.writeFieldStop()
15170 
    oprot.writeStructEnd()
15171 
 
15172 
  def validate(self):
15173 
    return
15174 
 
15175 
 
15176 
  def __repr__(self):
15177 
    L = ['%s=%r' % (key, value)
15178 
      for key, value in self.__dict__.iteritems()]
15179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15180 
 
15181 
  def __eq__(self, other):
15182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15183 
 
15184 
  def __ne__(self, other):
15185 
    return not (self == other)
15186 
 
15187 
class getAllItemVouchers_args:
15188 
  """
15189 
  Attributes:
15190 
   - itemId
15191 
  """
15192 
 
15193 
  thrift_spec = (
15194 
    None, # 0
15195 
    (1, TType.I64, 'itemId', None, None, ), # 1
15196 
  )
15197 
 
15198 
  def __init__(self, itemId=None,):
15199 
    self.itemId = itemId
15200 
 
15201 
  def read(self, iprot):
15202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15204 
      return
15205 
    iprot.readStructBegin()
15206 
    while True:
15207 
      (fname, ftype, fid) = iprot.readFieldBegin()
15208 
      if ftype == TType.STOP:
15209 
        break
15210 
      if fid == 1:
15211 
        if ftype == TType.I64:
15212 
          self.itemId = iprot.readI64();
15213 
        else:
15214 
          iprot.skip(ftype)
15215 
      else:
15216 
        iprot.skip(ftype)
15217 
      iprot.readFieldEnd()
15218 
    iprot.readStructEnd()
15219 
 
15220 
  def write(self, oprot):
15221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15223 
      return
15224 
    oprot.writeStructBegin('getAllItemVouchers_args')
15225 
    if self.itemId is not None:
15226 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15227 
      oprot.writeI64(self.itemId)
15228 
      oprot.writeFieldEnd()
15229 
    oprot.writeFieldStop()
15230 
    oprot.writeStructEnd()
15231 
 
15232 
  def validate(self):
15233 
    return
15234 
 
15235 
 
15236 
  def __repr__(self):
15237 
    L = ['%s=%r' % (key, value)
15238 
      for key, value in self.__dict__.iteritems()]
15239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15240 
 
15241 
  def __eq__(self, other):
15242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15243 
 
15244 
  def __ne__(self, other):
15245 
    return not (self == other)
15246 
 
15247 
class getAllItemVouchers_result:
15248 
  """
15249 
  Attributes:
15250 
   - success
15251 
  """
15252 
 
15253 
  thrift_spec = (
15254 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15255 
  )
15256 
 
15257 
  def __init__(self, success=None,):
15258 
    self.success = success
15259 
 
15260 
  def read(self, iprot):
15261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15263 
      return
15264 
    iprot.readStructBegin()
15265 
    while True:
15266 
      (fname, ftype, fid) = iprot.readFieldBegin()
15267 
      if ftype == TType.STOP:
15268 
        break
15269 
      if fid == 0:
15270 
        if ftype == TType.LIST:
15271 
          self.success = []
7438 amit.gupta 15272 
          (_etype289, _size286) = iprot.readListBegin()
15273 
          for _i290 in xrange(_size286):
15274 
            _elem291 = VoucherItemMapping()
15275 
            _elem291.read(iprot)
15276 
            self.success.append(_elem291)
5944 mandeep.dh 15277 
          iprot.readListEnd()
15278 
        else:
15279 
          iprot.skip(ftype)
15280 
      else:
15281 
        iprot.skip(ftype)
15282 
      iprot.readFieldEnd()
15283 
    iprot.readStructEnd()
15284 
 
15285 
  def write(self, oprot):
15286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15288 
      return
15289 
    oprot.writeStructBegin('getAllItemVouchers_result')
15290 
    if self.success is not None:
15291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15293 
      for iter292 in self.success:
15294 
        iter292.write(oprot)
5944 mandeep.dh 15295 
      oprot.writeListEnd()
15296 
      oprot.writeFieldEnd()
15297 
    oprot.writeFieldStop()
15298 
    oprot.writeStructEnd()
15299 
 
15300 
  def validate(self):
15301 
    return
15302 
 
15303 
 
15304 
  def __repr__(self):
15305 
    L = ['%s=%r' % (key, value)
15306 
      for key, value in self.__dict__.iteritems()]
15307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15308 
 
15309 
  def __eq__(self, other):
15310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15311 
 
15312 
  def __ne__(self, other):
15313 
    return not (self == other)
15314 
 
15315 
class isValidCatalogItemId_args:
15316 
  """
15317 
  Attributes:
15318 
   - catalog_item_id
15319 
  """
15320 
 
15321 
  thrift_spec = (
15322 
    None, # 0
15323 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15324 
  )
15325 
 
15326 
  def __init__(self, catalog_item_id=None,):
15327 
    self.catalog_item_id = catalog_item_id
15328 
 
15329 
  def read(self, iprot):
15330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15332 
      return
15333 
    iprot.readStructBegin()
15334 
    while True:
15335 
      (fname, ftype, fid) = iprot.readFieldBegin()
15336 
      if ftype == TType.STOP:
15337 
        break
15338 
      if fid == 1:
15339 
        if ftype == TType.I64:
15340 
          self.catalog_item_id = iprot.readI64();
15341 
        else:
15342 
          iprot.skip(ftype)
15343 
      else:
15344 
        iprot.skip(ftype)
15345 
      iprot.readFieldEnd()
15346 
    iprot.readStructEnd()
15347 
 
15348 
  def write(self, oprot):
15349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15351 
      return
15352 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15353 
    if self.catalog_item_id is not None:
15354 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15355 
      oprot.writeI64(self.catalog_item_id)
15356 
      oprot.writeFieldEnd()
15357 
    oprot.writeFieldStop()
15358 
    oprot.writeStructEnd()
15359 
 
15360 
  def validate(self):
15361 
    return
15362 
 
15363 
 
15364 
  def __repr__(self):
15365 
    L = ['%s=%r' % (key, value)
15366 
      for key, value in self.__dict__.iteritems()]
15367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15368 
 
15369 
  def __eq__(self, other):
15370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15371 
 
15372 
  def __ne__(self, other):
15373 
    return not (self == other)
15374 
 
15375 
class isValidCatalogItemId_result:
15376 
  """
15377 
  Attributes:
15378 
   - success
15379 
  """
15380 
 
15381 
  thrift_spec = (
15382 
    (0, TType.BOOL, 'success', None, None, ), # 0
15383 
  )
15384 
 
15385 
  def __init__(self, success=None,):
15386 
    self.success = success
15387 
 
15388 
  def read(self, iprot):
15389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15391 
      return
15392 
    iprot.readStructBegin()
15393 
    while True:
15394 
      (fname, ftype, fid) = iprot.readFieldBegin()
15395 
      if ftype == TType.STOP:
15396 
        break
15397 
      if fid == 0:
15398 
        if ftype == TType.BOOL:
15399 
          self.success = iprot.readBool();
15400 
        else:
15401 
          iprot.skip(ftype)
15402 
      else:
15403 
        iprot.skip(ftype)
15404 
      iprot.readFieldEnd()
15405 
    iprot.readStructEnd()
15406 
 
15407 
  def write(self, oprot):
15408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15410 
      return
15411 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15412 
    if self.success is not None:
15413 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15414 
      oprot.writeBool(self.success)
15415 
      oprot.writeFieldEnd()
15416 
    oprot.writeFieldStop()
15417 
    oprot.writeStructEnd()
15418 
 
15419 
  def validate(self):
15420 
    return
15421 
 
15422 
 
15423 
  def __repr__(self):
15424 
    L = ['%s=%r' % (key, value)
15425 
      for key, value in self.__dict__.iteritems()]
15426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15427 
 
15428 
  def __eq__(self, other):
15429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15430 
 
15431 
  def __ne__(self, other):
15432 
    return not (self == other)
6039 amit.gupta 15433 
 
15434 
class getVatPercentageForItem_args:
15435 
  """
15436 
  Attributes:
15437 
   - itemId
7330 amit.gupta 15438 
   - stateId
6039 amit.gupta 15439 
   - price
15440 
  """
15441 
 
15442 
  thrift_spec = (
15443 
    None, # 0
15444 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15445 
    (2, TType.I64, 'stateId', None, None, ), # 2
15446 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15447 
  )
15448 
 
7330 amit.gupta 15449 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15450 
    self.itemId = itemId
7330 amit.gupta 15451 
    self.stateId = stateId
6039 amit.gupta 15452 
    self.price = price
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 == 1:
15464 
        if ftype == TType.I64:
15465 
          self.itemId = iprot.readI64();
15466 
        else:
15467 
          iprot.skip(ftype)
15468 
      elif fid == 2:
7330 amit.gupta 15469 
        if ftype == TType.I64:
15470 
          self.stateId = iprot.readI64();
15471 
        else:
15472 
          iprot.skip(ftype)
15473 
      elif fid == 3:
6039 amit.gupta 15474 
        if ftype == TType.DOUBLE:
15475 
          self.price = iprot.readDouble();
15476 
        else:
15477 
          iprot.skip(ftype)
15478 
      else:
15479 
        iprot.skip(ftype)
15480 
      iprot.readFieldEnd()
15481 
    iprot.readStructEnd()
15482 
 
15483 
  def write(self, oprot):
15484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15486 
      return
15487 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15488 
    if self.itemId is not None:
15489 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15490 
      oprot.writeI64(self.itemId)
15491 
      oprot.writeFieldEnd()
7330 amit.gupta 15492 
    if self.stateId is not None:
15493 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15494 
      oprot.writeI64(self.stateId)
15495 
      oprot.writeFieldEnd()
6039 amit.gupta 15496 
    if self.price is not None:
7330 amit.gupta 15497 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15498 
      oprot.writeDouble(self.price)
15499 
      oprot.writeFieldEnd()
15500 
    oprot.writeFieldStop()
15501 
    oprot.writeStructEnd()
15502 
 
15503 
  def validate(self):
15504 
    return
15505 
 
15506 
 
15507 
  def __repr__(self):
15508 
    L = ['%s=%r' % (key, value)
15509 
      for key, value in self.__dict__.iteritems()]
15510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15511 
 
15512 
  def __eq__(self, other):
15513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15514 
 
15515 
  def __ne__(self, other):
15516 
    return not (self == other)
15517 
 
15518 
class getVatPercentageForItem_result:
15519 
  """
15520 
  Attributes:
15521 
   - success
7340 amit.gupta 15522 
   - cex
6039 amit.gupta 15523 
  """
15524 
 
15525 
  thrift_spec = (
15526 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15527 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15528 
  )
15529 
 
7340 amit.gupta 15530 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15531 
    self.success = success
7340 amit.gupta 15532 
    self.cex = cex
6039 amit.gupta 15533 
 
15534 
  def read(self, iprot):
15535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15537 
      return
15538 
    iprot.readStructBegin()
15539 
    while True:
15540 
      (fname, ftype, fid) = iprot.readFieldBegin()
15541 
      if ftype == TType.STOP:
15542 
        break
15543 
      if fid == 0:
15544 
        if ftype == TType.DOUBLE:
15545 
          self.success = iprot.readDouble();
15546 
        else:
15547 
          iprot.skip(ftype)
7340 amit.gupta 15548 
      elif fid == 1:
15549 
        if ftype == TType.STRUCT:
15550 
          self.cex = CatalogServiceException()
15551 
          self.cex.read(iprot)
15552 
        else:
15553 
          iprot.skip(ftype)
6039 amit.gupta 15554 
      else:
15555 
        iprot.skip(ftype)
15556 
      iprot.readFieldEnd()
15557 
    iprot.readStructEnd()
15558 
 
15559 
  def write(self, oprot):
15560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15562 
      return
15563 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15564 
    if self.success is not None:
15565 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15566 
      oprot.writeDouble(self.success)
15567 
      oprot.writeFieldEnd()
7340 amit.gupta 15568 
    if self.cex is not None:
15569 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15570 
      self.cex.write(oprot)
15571 
      oprot.writeFieldEnd()
6039 amit.gupta 15572 
    oprot.writeFieldStop()
15573 
    oprot.writeStructEnd()
15574 
 
15575 
  def validate(self):
15576 
    return
15577 
 
15578 
 
15579 
  def __repr__(self):
15580 
    L = ['%s=%r' % (key, value)
15581 
      for key, value in self.__dict__.iteritems()]
15582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15583 
 
15584 
  def __eq__(self, other):
15585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15586 
 
15587 
  def __ne__(self, other):
15588 
    return not (self == other)
15589 
 
15590 
class getVatAmountForItem_args:
15591 
  """
15592 
  Attributes:
15593 
   - itemId
15594 
   - price
15595 
  """
15596 
 
15597 
  thrift_spec = (
15598 
    None, # 0
15599 
    (1, TType.I64, 'itemId', None, None, ), # 1
15600 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15601 
  )
15602 
 
15603 
  def __init__(self, itemId=None, price=None,):
15604 
    self.itemId = itemId
15605 
    self.price = price
15606 
 
15607 
  def read(self, iprot):
15608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15610 
      return
15611 
    iprot.readStructBegin()
15612 
    while True:
15613 
      (fname, ftype, fid) = iprot.readFieldBegin()
15614 
      if ftype == TType.STOP:
15615 
        break
15616 
      if fid == 1:
15617 
        if ftype == TType.I64:
15618 
          self.itemId = iprot.readI64();
15619 
        else:
15620 
          iprot.skip(ftype)
15621 
      elif fid == 2:
15622 
        if ftype == TType.DOUBLE:
15623 
          self.price = iprot.readDouble();
15624 
        else:
15625 
          iprot.skip(ftype)
15626 
      else:
15627 
        iprot.skip(ftype)
15628 
      iprot.readFieldEnd()
15629 
    iprot.readStructEnd()
15630 
 
15631 
  def write(self, oprot):
15632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15634 
      return
15635 
    oprot.writeStructBegin('getVatAmountForItem_args')
15636 
    if self.itemId is not None:
15637 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15638 
      oprot.writeI64(self.itemId)
15639 
      oprot.writeFieldEnd()
15640 
    if self.price is not None:
15641 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15642 
      oprot.writeDouble(self.price)
15643 
      oprot.writeFieldEnd()
15644 
    oprot.writeFieldStop()
15645 
    oprot.writeStructEnd()
15646 
 
15647 
  def validate(self):
15648 
    return
15649 
 
15650 
 
15651 
  def __repr__(self):
15652 
    L = ['%s=%r' % (key, value)
15653 
      for key, value in self.__dict__.iteritems()]
15654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15655 
 
15656 
  def __eq__(self, other):
15657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15658 
 
15659 
  def __ne__(self, other):
15660 
    return not (self == other)
15661 
 
15662 
class getVatAmountForItem_result:
15663 
  """
15664 
  Attributes:
15665 
   - success
15666 
  """
15667 
 
15668 
  thrift_spec = (
15669 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15670 
  )
15671 
 
15672 
  def __init__(self, success=None,):
15673 
    self.success = success
15674 
 
15675 
  def read(self, iprot):
15676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15678 
      return
15679 
    iprot.readStructBegin()
15680 
    while True:
15681 
      (fname, ftype, fid) = iprot.readFieldBegin()
15682 
      if ftype == TType.STOP:
15683 
        break
15684 
      if fid == 0:
15685 
        if ftype == TType.DOUBLE:
15686 
          self.success = iprot.readDouble();
15687 
        else:
15688 
          iprot.skip(ftype)
15689 
      else:
15690 
        iprot.skip(ftype)
15691 
      iprot.readFieldEnd()
15692 
    iprot.readStructEnd()
15693 
 
15694 
  def write(self, oprot):
15695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15697 
      return
15698 
    oprot.writeStructBegin('getVatAmountForItem_result')
15699 
    if self.success is not None:
15700 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15701 
      oprot.writeDouble(self.success)
15702 
      oprot.writeFieldEnd()
15703 
    oprot.writeFieldStop()
15704 
    oprot.writeStructEnd()
15705 
 
15706 
  def validate(self):
15707 
    return
15708 
 
15709 
 
15710 
  def __repr__(self):
15711 
    L = ['%s=%r' % (key, value)
15712 
      for key, value in self.__dict__.iteritems()]
15713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15714 
 
15715 
  def __eq__(self, other):
15716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15717 
 
15718 
  def __ne__(self, other):
15719 
    return not (self == other)
6531 vikram.rag 15720 
 
15721 
class getAllIgnoredInventoryUpdateItemsList_args:
15722 
  """
15723 
  Attributes:
15724 
   - offset
15725 
   - limit
15726 
  """
15727 
 
15728 
  thrift_spec = (
15729 
    None, # 0
15730 
    (1, TType.I32, 'offset', None, None, ), # 1
15731 
    (2, TType.I32, 'limit', None, None, ), # 2
15732 
  )
15733 
 
15734 
  def __init__(self, offset=None, limit=None,):
15735 
    self.offset = offset
15736 
    self.limit = limit
15737 
 
15738 
  def read(self, iprot):
15739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15741 
      return
15742 
    iprot.readStructBegin()
15743 
    while True:
15744 
      (fname, ftype, fid) = iprot.readFieldBegin()
15745 
      if ftype == TType.STOP:
15746 
        break
15747 
      if fid == 1:
15748 
        if ftype == TType.I32:
15749 
          self.offset = iprot.readI32();
15750 
        else:
15751 
          iprot.skip(ftype)
15752 
      elif fid == 2:
15753 
        if ftype == TType.I32:
15754 
          self.limit = iprot.readI32();
15755 
        else:
15756 
          iprot.skip(ftype)
15757 
      else:
15758 
        iprot.skip(ftype)
15759 
      iprot.readFieldEnd()
15760 
    iprot.readStructEnd()
15761 
 
15762 
  def write(self, oprot):
15763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15765 
      return
15766 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15767 
    if self.offset is not None:
15768 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15769 
      oprot.writeI32(self.offset)
15770 
      oprot.writeFieldEnd()
15771 
    if self.limit is not None:
15772 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15773 
      oprot.writeI32(self.limit)
15774 
      oprot.writeFieldEnd()
15775 
    oprot.writeFieldStop()
15776 
    oprot.writeStructEnd()
15777 
 
15778 
  def validate(self):
15779 
    return
15780 
 
15781 
 
15782 
  def __repr__(self):
15783 
    L = ['%s=%r' % (key, value)
15784 
      for key, value in self.__dict__.iteritems()]
15785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15786 
 
15787 
  def __eq__(self, other):
15788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15789 
 
15790 
  def __ne__(self, other):
15791 
    return not (self == other)
15792 
 
15793 
class getAllIgnoredInventoryUpdateItemsList_result:
15794 
  """
15795 
  Attributes:
15796 
   - success
15797 
  """
15798 
 
15799 
  thrift_spec = (
15800 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15801 
  )
15802 
 
15803 
  def __init__(self, success=None,):
15804 
    self.success = success
15805 
 
15806 
  def read(self, iprot):
15807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15809 
      return
15810 
    iprot.readStructBegin()
15811 
    while True:
15812 
      (fname, ftype, fid) = iprot.readFieldBegin()
15813 
      if ftype == TType.STOP:
15814 
        break
15815 
      if fid == 0:
15816 
        if ftype == TType.LIST:
15817 
          self.success = []
7438 amit.gupta 15818 
          (_etype296, _size293) = iprot.readListBegin()
15819 
          for _i297 in xrange(_size293):
15820 
            _elem298 = Item()
15821 
            _elem298.read(iprot)
15822 
            self.success.append(_elem298)
6531 vikram.rag 15823 
          iprot.readListEnd()
15824 
        else:
15825 
          iprot.skip(ftype)
15826 
      else:
15827 
        iprot.skip(ftype)
15828 
      iprot.readFieldEnd()
15829 
    iprot.readStructEnd()
15830 
 
15831 
  def write(self, oprot):
15832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15834 
      return
15835 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15836 
    if self.success is not None:
15837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15839 
      for iter299 in self.success:
15840 
        iter299.write(oprot)
6531 vikram.rag 15841 
      oprot.writeListEnd()
15842 
      oprot.writeFieldEnd()
15843 
    oprot.writeFieldStop()
15844 
    oprot.writeStructEnd()
15845 
 
15846 
  def validate(self):
15847 
    return
15848 
 
15849 
 
15850 
  def __repr__(self):
15851 
    L = ['%s=%r' % (key, value)
15852 
      for key, value in self.__dict__.iteritems()]
15853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15854 
 
15855 
  def __eq__(self, other):
15856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15857 
 
15858 
  def __ne__(self, other):
15859 
    return not (self == other)
6805 anupam.sin 15860 
 
6821 amar.kumar 15861 
class getAllAliveItems_args:
15862 
 
15863 
  thrift_spec = (
15864 
  )
15865 
 
15866 
  def read(self, iprot):
15867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15869 
      return
15870 
    iprot.readStructBegin()
15871 
    while True:
15872 
      (fname, ftype, fid) = iprot.readFieldBegin()
15873 
      if ftype == TType.STOP:
15874 
        break
15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('getAllAliveItems_args')
15885 
    oprot.writeFieldStop()
15886 
    oprot.writeStructEnd()
15887 
 
15888 
  def validate(self):
15889 
    return
15890 
 
15891 
 
15892 
  def __repr__(self):
15893 
    L = ['%s=%r' % (key, value)
15894 
      for key, value in self.__dict__.iteritems()]
15895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15896 
 
15897 
  def __eq__(self, other):
15898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15899 
 
15900 
  def __ne__(self, other):
15901 
    return not (self == other)
15902 
 
15903 
class getAllAliveItems_result:
15904 
  """
15905 
  Attributes:
15906 
   - success
15907 
  """
15908 
 
15909 
  thrift_spec = (
15910 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15911 
  )
15912 
 
15913 
  def __init__(self, success=None,):
15914 
    self.success = success
15915 
 
15916 
  def read(self, iprot):
15917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15919 
      return
15920 
    iprot.readStructBegin()
15921 
    while True:
15922 
      (fname, ftype, fid) = iprot.readFieldBegin()
15923 
      if ftype == TType.STOP:
15924 
        break
15925 
      if fid == 0:
15926 
        if ftype == TType.LIST:
15927 
          self.success = []
7438 amit.gupta 15928 
          (_etype303, _size300) = iprot.readListBegin()
15929 
          for _i304 in xrange(_size300):
15930 
            _elem305 = Item()
15931 
            _elem305.read(iprot)
15932 
            self.success.append(_elem305)
6821 amar.kumar 15933 
          iprot.readListEnd()
15934 
        else:
15935 
          iprot.skip(ftype)
15936 
      else:
15937 
        iprot.skip(ftype)
15938 
      iprot.readFieldEnd()
15939 
    iprot.readStructEnd()
15940 
 
15941 
  def write(self, oprot):
15942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15944 
      return
15945 
    oprot.writeStructBegin('getAllAliveItems_result')
15946 
    if self.success is not None:
15947 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15948 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15949 
      for iter306 in self.success:
15950 
        iter306.write(oprot)
6821 amar.kumar 15951 
      oprot.writeListEnd()
15952 
      oprot.writeFieldEnd()
15953 
    oprot.writeFieldStop()
15954 
    oprot.writeStructEnd()
15955 
 
15956 
  def validate(self):
15957 
    return
15958 
 
15959 
 
15960 
  def __repr__(self):
15961 
    L = ['%s=%r' % (key, value)
15962 
      for key, value in self.__dict__.iteritems()]
15963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15964 
 
15965 
  def __eq__(self, other):
15966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15967 
 
15968 
  def __ne__(self, other):
15969 
    return not (self == other)
15970 
 
6805 anupam.sin 15971 
class getInsuranceAmount_args:
15972 
  """
15973 
  Attributes:
15974 
   - itemId
6921 anupam.sin 15975 
   - price
6805 anupam.sin 15976 
   - insurerId
15977 
   - quantity
15978 
  """
15979 
 
15980 
  thrift_spec = (
15981 
    None, # 0
15982 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15983 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15984 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15985 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15986 
  )
15987 
 
6921 anupam.sin 15988 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15989 
    self.itemId = itemId
6921 anupam.sin 15990 
    self.price = price
6805 anupam.sin 15991 
    self.insurerId = insurerId
15992 
    self.quantity = quantity
15993 
 
15994 
  def read(self, iprot):
15995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15997 
      return
15998 
    iprot.readStructBegin()
15999 
    while True:
16000 
      (fname, ftype, fid) = iprot.readFieldBegin()
16001 
      if ftype == TType.STOP:
16002 
        break
16003 
      if fid == 1:
16004 
        if ftype == TType.I64:
16005 
          self.itemId = iprot.readI64();
16006 
        else:
16007 
          iprot.skip(ftype)
16008 
      elif fid == 2:
6921 anupam.sin 16009 
        if ftype == TType.DOUBLE:
16010 
          self.price = iprot.readDouble();
16011 
        else:
16012 
          iprot.skip(ftype)
16013 
      elif fid == 3:
6805 anupam.sin 16014 
        if ftype == TType.I64:
16015 
          self.insurerId = iprot.readI64();
16016 
        else:
16017 
          iprot.skip(ftype)
6921 anupam.sin 16018 
      elif fid == 4:
6805 anupam.sin 16019 
        if ftype == TType.I64:
16020 
          self.quantity = iprot.readI64();
16021 
        else:
16022 
          iprot.skip(ftype)
16023 
      else:
16024 
        iprot.skip(ftype)
16025 
      iprot.readFieldEnd()
16026 
    iprot.readStructEnd()
16027 
 
16028 
  def write(self, oprot):
16029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16031 
      return
16032 
    oprot.writeStructBegin('getInsuranceAmount_args')
16033 
    if self.itemId is not None:
16034 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16035 
      oprot.writeI64(self.itemId)
16036 
      oprot.writeFieldEnd()
6921 anupam.sin 16037 
    if self.price is not None:
16038 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
16039 
      oprot.writeDouble(self.price)
16040 
      oprot.writeFieldEnd()
6805 anupam.sin 16041 
    if self.insurerId is not None:
6921 anupam.sin 16042 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 16043 
      oprot.writeI64(self.insurerId)
16044 
      oprot.writeFieldEnd()
16045 
    if self.quantity is not None:
6921 anupam.sin 16046 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 16047 
      oprot.writeI64(self.quantity)
16048 
      oprot.writeFieldEnd()
16049 
    oprot.writeFieldStop()
16050 
    oprot.writeStructEnd()
16051 
 
16052 
  def validate(self):
16053 
    return
16054 
 
16055 
 
16056 
  def __repr__(self):
16057 
    L = ['%s=%r' % (key, value)
16058 
      for key, value in self.__dict__.iteritems()]
16059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16060 
 
16061 
  def __eq__(self, other):
16062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16063 
 
16064 
  def __ne__(self, other):
16065 
    return not (self == other)
16066 
 
16067 
class getInsuranceAmount_result:
16068 
  """
16069 
  Attributes:
16070 
   - success
16071 
  """
16072 
 
16073 
  thrift_spec = (
16074 
    (0, TType.I64, 'success', None, None, ), # 0
16075 
  )
16076 
 
16077 
  def __init__(self, success=None,):
16078 
    self.success = success
16079 
 
16080 
  def read(self, iprot):
16081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16083 
      return
16084 
    iprot.readStructBegin()
16085 
    while True:
16086 
      (fname, ftype, fid) = iprot.readFieldBegin()
16087 
      if ftype == TType.STOP:
16088 
        break
16089 
      if fid == 0:
16090 
        if ftype == TType.I64:
16091 
          self.success = iprot.readI64();
16092 
        else:
16093 
          iprot.skip(ftype)
16094 
      else:
16095 
        iprot.skip(ftype)
16096 
      iprot.readFieldEnd()
16097 
    iprot.readStructEnd()
16098 
 
16099 
  def write(self, oprot):
16100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16102 
      return
16103 
    oprot.writeStructBegin('getInsuranceAmount_result')
16104 
    if self.success is not None:
16105 
      oprot.writeFieldBegin('success', TType.I64, 0)
16106 
      oprot.writeI64(self.success)
16107 
      oprot.writeFieldEnd()
16108 
    oprot.writeFieldStop()
16109 
    oprot.writeStructEnd()
16110 
 
16111 
  def validate(self):
16112 
    return
16113 
 
16114 
 
16115 
  def __repr__(self):
16116 
    L = ['%s=%r' % (key, value)
16117 
      for key, value in self.__dict__.iteritems()]
16118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16119 
 
16120 
  def __eq__(self, other):
16121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16122 
 
16123 
  def __ne__(self, other):
16124 
    return not (self == other)
16125 
 
16126 
class getInsurer_args:
16127 
  """
16128 
  Attributes:
16129 
   - insurerId
16130 
  """
16131 
 
16132 
  thrift_spec = (
16133 
    None, # 0
16134 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16135 
  )
16136 
 
16137 
  def __init__(self, insurerId=None,):
16138 
    self.insurerId = insurerId
16139 
 
16140 
  def read(self, iprot):
16141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16143 
      return
16144 
    iprot.readStructBegin()
16145 
    while True:
16146 
      (fname, ftype, fid) = iprot.readFieldBegin()
16147 
      if ftype == TType.STOP:
16148 
        break
16149 
      if fid == 1:
16150 
        if ftype == TType.I64:
16151 
          self.insurerId = iprot.readI64();
16152 
        else:
16153 
          iprot.skip(ftype)
16154 
      else:
16155 
        iprot.skip(ftype)
16156 
      iprot.readFieldEnd()
16157 
    iprot.readStructEnd()
16158 
 
16159 
  def write(self, oprot):
16160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16162 
      return
16163 
    oprot.writeStructBegin('getInsurer_args')
16164 
    if self.insurerId is not None:
16165 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16166 
      oprot.writeI64(self.insurerId)
16167 
      oprot.writeFieldEnd()
16168 
    oprot.writeFieldStop()
16169 
    oprot.writeStructEnd()
16170 
 
16171 
  def validate(self):
16172 
    return
16173 
 
16174 
 
16175 
  def __repr__(self):
16176 
    L = ['%s=%r' % (key, value)
16177 
      for key, value in self.__dict__.iteritems()]
16178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16179 
 
16180 
  def __eq__(self, other):
16181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16182 
 
16183 
  def __ne__(self, other):
16184 
    return not (self == other)
16185 
 
16186 
class getInsurer_result:
16187 
  """
16188 
  Attributes:
16189 
   - success
16190 
  """
16191 
 
16192 
  thrift_spec = (
16193 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
16194 
  )
16195 
 
16196 
  def __init__(self, success=None,):
16197 
    self.success = success
16198 
 
16199 
  def read(self, iprot):
16200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16202 
      return
16203 
    iprot.readStructBegin()
16204 
    while True:
16205 
      (fname, ftype, fid) = iprot.readFieldBegin()
16206 
      if ftype == TType.STOP:
16207 
        break
16208 
      if fid == 0:
16209 
        if ftype == TType.STRUCT:
16210 
          self.success = Insurer()
16211 
          self.success.read(iprot)
16212 
        else:
16213 
          iprot.skip(ftype)
16214 
      else:
16215 
        iprot.skip(ftype)
16216 
      iprot.readFieldEnd()
16217 
    iprot.readStructEnd()
16218 
 
16219 
  def write(self, oprot):
16220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16222 
      return
16223 
    oprot.writeStructBegin('getInsurer_result')
16224 
    if self.success is not None:
16225 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16226 
      self.success.write(oprot)
16227 
      oprot.writeFieldEnd()
16228 
    oprot.writeFieldStop()
16229 
    oprot.writeStructEnd()
16230 
 
16231 
  def validate(self):
16232 
    return
16233 
 
16234 
 
16235 
  def __repr__(self):
16236 
    L = ['%s=%r' % (key, value)
16237 
      for key, value in self.__dict__.iteritems()]
16238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16239 
 
16240 
  def __eq__(self, other):
16241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16242 
 
16243 
  def __ne__(self, other):
16244 
    return not (self == other)
6838 vikram.rag 16245 
 
16246 
class getAllInsurers_args:
16247 
 
16248 
  thrift_spec = (
16249 
  )
16250 
 
16251 
  def read(self, iprot):
16252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16254 
      return
16255 
    iprot.readStructBegin()
16256 
    while True:
16257 
      (fname, ftype, fid) = iprot.readFieldBegin()
16258 
      if ftype == TType.STOP:
16259 
        break
16260 
      else:
16261 
        iprot.skip(ftype)
16262 
      iprot.readFieldEnd()
16263 
    iprot.readStructEnd()
16264 
 
16265 
  def write(self, oprot):
16266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16268 
      return
16269 
    oprot.writeStructBegin('getAllInsurers_args')
16270 
    oprot.writeFieldStop()
16271 
    oprot.writeStructEnd()
16272 
 
16273 
  def validate(self):
16274 
    return
16275 
 
16276 
 
16277 
  def __repr__(self):
16278 
    L = ['%s=%r' % (key, value)
16279 
      for key, value in self.__dict__.iteritems()]
16280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16281 
 
16282 
  def __eq__(self, other):
16283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16284 
 
16285 
  def __ne__(self, other):
16286 
    return not (self == other)
16287 
 
16288 
class getAllInsurers_result:
16289 
  """
16290 
  Attributes:
16291 
   - success
16292 
  """
16293 
 
16294 
  thrift_spec = (
16295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16296 
  )
16297 
 
16298 
  def __init__(self, success=None,):
16299 
    self.success = success
16300 
 
16301 
  def read(self, iprot):
16302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16304 
      return
16305 
    iprot.readStructBegin()
16306 
    while True:
16307 
      (fname, ftype, fid) = iprot.readFieldBegin()
16308 
      if ftype == TType.STOP:
16309 
        break
16310 
      if fid == 0:
16311 
        if ftype == TType.LIST:
16312 
          self.success = []
7438 amit.gupta 16313 
          (_etype310, _size307) = iprot.readListBegin()
16314 
          for _i311 in xrange(_size307):
16315 
            _elem312 = Insurer()
16316 
            _elem312.read(iprot)
16317 
            self.success.append(_elem312)
6838 vikram.rag 16318 
          iprot.readListEnd()
16319 
        else:
16320 
          iprot.skip(ftype)
16321 
      else:
16322 
        iprot.skip(ftype)
16323 
      iprot.readFieldEnd()
16324 
    iprot.readStructEnd()
16325 
 
16326 
  def write(self, oprot):
16327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16329 
      return
16330 
    oprot.writeStructBegin('getAllInsurers_result')
16331 
    if self.success is not None:
16332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16334 
      for iter313 in self.success:
16335 
        iter313.write(oprot)
6838 vikram.rag 16336 
      oprot.writeListEnd()
16337 
      oprot.writeFieldEnd()
16338 
    oprot.writeFieldStop()
16339 
    oprot.writeStructEnd()
16340 
 
16341 
  def validate(self):
16342 
    return
16343 
 
16344 
 
16345 
  def __repr__(self):
16346 
    L = ['%s=%r' % (key, value)
16347 
      for key, value in self.__dict__.iteritems()]
16348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16349 
 
16350 
  def __eq__(self, other):
16351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16352 
 
16353 
  def __ne__(self, other):
16354 
    return not (self == other)
6962 rajveer 16355 
 
16356 
class updateInsuranceDeclaredAmount_args:
16357 
  """
16358 
  Attributes:
16359 
   - insurerId
16360 
   - amount
16361 
  """
16362 
 
16363 
  thrift_spec = (
16364 
    None, # 0
16365 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16366 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16367 
  )
16368 
 
16369 
  def __init__(self, insurerId=None, amount=None,):
16370 
    self.insurerId = insurerId
16371 
    self.amount = amount
16372 
 
16373 
  def read(self, iprot):
16374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16376 
      return
16377 
    iprot.readStructBegin()
16378 
    while True:
16379 
      (fname, ftype, fid) = iprot.readFieldBegin()
16380 
      if ftype == TType.STOP:
16381 
        break
16382 
      if fid == 1:
16383 
        if ftype == TType.I64:
16384 
          self.insurerId = iprot.readI64();
16385 
        else:
16386 
          iprot.skip(ftype)
16387 
      elif fid == 2:
16388 
        if ftype == TType.DOUBLE:
16389 
          self.amount = iprot.readDouble();
16390 
        else:
16391 
          iprot.skip(ftype)
16392 
      else:
16393 
        iprot.skip(ftype)
16394 
      iprot.readFieldEnd()
16395 
    iprot.readStructEnd()
16396 
 
16397 
  def write(self, oprot):
16398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16400 
      return
16401 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16402 
    if self.insurerId is not None:
16403 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16404 
      oprot.writeI64(self.insurerId)
16405 
      oprot.writeFieldEnd()
16406 
    if self.amount is not None:
16407 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16408 
      oprot.writeDouble(self.amount)
16409 
      oprot.writeFieldEnd()
16410 
    oprot.writeFieldStop()
16411 
    oprot.writeStructEnd()
16412 
 
16413 
  def validate(self):
16414 
    return
16415 
 
16416 
 
16417 
  def __repr__(self):
16418 
    L = ['%s=%r' % (key, value)
16419 
      for key, value in self.__dict__.iteritems()]
16420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16421 
 
16422 
  def __eq__(self, other):
16423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16424 
 
16425 
  def __ne__(self, other):
16426 
    return not (self == other)
16427 
 
16428 
class updateInsuranceDeclaredAmount_result:
16429 
 
16430 
  thrift_spec = (
16431 
  )
16432 
 
16433 
  def read(self, iprot):
16434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16436 
      return
16437 
    iprot.readStructBegin()
16438 
    while True:
16439 
      (fname, ftype, fid) = iprot.readFieldBegin()
16440 
      if ftype == TType.STOP:
16441 
        break
16442 
      else:
16443 
        iprot.skip(ftype)
16444 
      iprot.readFieldEnd()
16445 
    iprot.readStructEnd()
16446 
 
16447 
  def write(self, oprot):
16448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16450 
      return
16451 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16452 
    oprot.writeFieldStop()
16453 
    oprot.writeStructEnd()
16454 
 
16455 
  def validate(self):
16456 
    return
16457 
 
16458 
 
16459 
  def __repr__(self):
16460 
    L = ['%s=%r' % (key, value)
16461 
      for key, value in self.__dict__.iteritems()]
16462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16463 
 
16464 
  def __eq__(self, other):
16465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16466 
 
16467 
  def __ne__(self, other):
16468 
    return not (self == other)
7190 amar.kumar 16469 
 
16470 
class getFreebieForItem_args:
16471 
  """
16472 
  Attributes:
16473 
   - itemId
16474 
  """
16475 
 
16476 
  thrift_spec = (
16477 
    None, # 0
16478 
    (1, TType.I64, 'itemId', None, None, ), # 1
16479 
  )
16480 
 
16481 
  def __init__(self, itemId=None,):
16482 
    self.itemId = itemId
16483 
 
16484 
  def read(self, iprot):
16485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16487 
      return
16488 
    iprot.readStructBegin()
16489 
    while True:
16490 
      (fname, ftype, fid) = iprot.readFieldBegin()
16491 
      if ftype == TType.STOP:
16492 
        break
16493 
      if fid == 1:
16494 
        if ftype == TType.I64:
16495 
          self.itemId = iprot.readI64();
16496 
        else:
16497 
          iprot.skip(ftype)
16498 
      else:
16499 
        iprot.skip(ftype)
16500 
      iprot.readFieldEnd()
16501 
    iprot.readStructEnd()
16502 
 
16503 
  def write(self, oprot):
16504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16506 
      return
16507 
    oprot.writeStructBegin('getFreebieForItem_args')
16508 
    if self.itemId is not None:
16509 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16510 
      oprot.writeI64(self.itemId)
16511 
      oprot.writeFieldEnd()
16512 
    oprot.writeFieldStop()
16513 
    oprot.writeStructEnd()
16514 
 
16515 
  def validate(self):
16516 
    return
16517 
 
16518 
 
16519 
  def __repr__(self):
16520 
    L = ['%s=%r' % (key, value)
16521 
      for key, value in self.__dict__.iteritems()]
16522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16523 
 
16524 
  def __eq__(self, other):
16525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16526 
 
16527 
  def __ne__(self, other):
16528 
    return not (self == other)
16529 
 
16530 
class getFreebieForItem_result:
16531 
  """
16532 
  Attributes:
16533 
   - success
16534 
  """
16535 
 
16536 
  thrift_spec = (
16537 
    (0, TType.I64, 'success', None, None, ), # 0
16538 
  )
16539 
 
16540 
  def __init__(self, success=None,):
16541 
    self.success = success
16542 
 
16543 
  def read(self, iprot):
16544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16546 
      return
16547 
    iprot.readStructBegin()
16548 
    while True:
16549 
      (fname, ftype, fid) = iprot.readFieldBegin()
16550 
      if ftype == TType.STOP:
16551 
        break
16552 
      if fid == 0:
16553 
        if ftype == TType.I64:
16554 
          self.success = iprot.readI64();
16555 
        else:
16556 
          iprot.skip(ftype)
16557 
      else:
16558 
        iprot.skip(ftype)
16559 
      iprot.readFieldEnd()
16560 
    iprot.readStructEnd()
16561 
 
16562 
  def write(self, oprot):
16563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16565 
      return
16566 
    oprot.writeStructBegin('getFreebieForItem_result')
16567 
    if self.success is not None:
16568 
      oprot.writeFieldBegin('success', TType.I64, 0)
16569 
      oprot.writeI64(self.success)
16570 
      oprot.writeFieldEnd()
16571 
    oprot.writeFieldStop()
16572 
    oprot.writeStructEnd()
16573 
 
16574 
  def validate(self):
16575 
    return
16576 
 
16577 
 
16578 
  def __repr__(self):
16579 
    L = ['%s=%r' % (key, value)
16580 
      for key, value in self.__dict__.iteritems()]
16581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16582 
 
16583 
  def __eq__(self, other):
16584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16585 
 
16586 
  def __ne__(self, other):
16587 
    return not (self == other)
16588 
 
16589 
class addOrUpdateFreebieForItem_args:
16590 
  """
16591 
  Attributes:
16592 
   - freebieItem
16593 
  """
16594 
 
16595 
  thrift_spec = (
16596 
    None, # 0
16597 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16598 
  )
16599 
 
16600 
  def __init__(self, freebieItem=None,):
16601 
    self.freebieItem = freebieItem
16602 
 
16603 
  def read(self, iprot):
16604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16606 
      return
16607 
    iprot.readStructBegin()
16608 
    while True:
16609 
      (fname, ftype, fid) = iprot.readFieldBegin()
16610 
      if ftype == TType.STOP:
16611 
        break
16612 
      if fid == 1:
16613 
        if ftype == TType.STRUCT:
16614 
          self.freebieItem = FreebieItem()
16615 
          self.freebieItem.read(iprot)
16616 
        else:
16617 
          iprot.skip(ftype)
16618 
      else:
16619 
        iprot.skip(ftype)
16620 
      iprot.readFieldEnd()
16621 
    iprot.readStructEnd()
16622 
 
16623 
  def write(self, oprot):
16624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16626 
      return
16627 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16628 
    if self.freebieItem is not None:
16629 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16630 
      self.freebieItem.write(oprot)
16631 
      oprot.writeFieldEnd()
16632 
    oprot.writeFieldStop()
16633 
    oprot.writeStructEnd()
16634 
 
16635 
  def validate(self):
16636 
    return
16637 
 
16638 
 
16639 
  def __repr__(self):
16640 
    L = ['%s=%r' % (key, value)
16641 
      for key, value in self.__dict__.iteritems()]
16642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16643 
 
16644 
  def __eq__(self, other):
16645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16646 
 
16647 
  def __ne__(self, other):
16648 
    return not (self == other)
16649 
 
16650 
class addOrUpdateFreebieForItem_result:
16651 
 
16652 
  thrift_spec = (
16653 
  )
16654 
 
16655 
  def read(self, iprot):
16656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16658 
      return
16659 
    iprot.readStructBegin()
16660 
    while True:
16661 
      (fname, ftype, fid) = iprot.readFieldBegin()
16662 
      if ftype == TType.STOP:
16663 
        break
16664 
      else:
16665 
        iprot.skip(ftype)
16666 
      iprot.readFieldEnd()
16667 
    iprot.readStructEnd()
16668 
 
16669 
  def write(self, oprot):
16670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16672 
      return
16673 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16674 
    oprot.writeFieldStop()
16675 
    oprot.writeStructEnd()
16676 
 
16677 
  def validate(self):
16678 
    return
16679 
 
16680 
 
16681 
  def __repr__(self):
16682 
    L = ['%s=%r' % (key, value)
16683 
      for key, value in self.__dict__.iteritems()]
16684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16685 
 
16686 
  def __eq__(self, other):
16687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16688 
 
16689 
  def __ne__(self, other):
16690 
    return not (self == other)
7256 rajveer 16691 
 
7272 amit.gupta 16692 
class addOrUpdateBrandInfo_args:
16693 
  """
16694 
  Attributes:
16695 
   - brandInfo
16696 
  """
16697 
 
16698 
  thrift_spec = (
16699 
    None, # 0
16700 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16701 
  )
16702 
 
16703 
  def __init__(self, brandInfo=None,):
16704 
    self.brandInfo = brandInfo
16705 
 
16706 
  def read(self, iprot):
16707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16709 
      return
16710 
    iprot.readStructBegin()
16711 
    while True:
16712 
      (fname, ftype, fid) = iprot.readFieldBegin()
16713 
      if ftype == TType.STOP:
16714 
        break
16715 
      if fid == 1:
16716 
        if ftype == TType.STRUCT:
16717 
          self.brandInfo = BrandInfo()
16718 
          self.brandInfo.read(iprot)
16719 
        else:
16720 
          iprot.skip(ftype)
16721 
      else:
16722 
        iprot.skip(ftype)
16723 
      iprot.readFieldEnd()
16724 
    iprot.readStructEnd()
16725 
 
16726 
  def write(self, oprot):
16727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16729 
      return
16730 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16731 
    if self.brandInfo is not None:
16732 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16733 
      self.brandInfo.write(oprot)
16734 
      oprot.writeFieldEnd()
16735 
    oprot.writeFieldStop()
16736 
    oprot.writeStructEnd()
16737 
 
16738 
  def validate(self):
16739 
    return
16740 
 
16741 
 
16742 
  def __repr__(self):
16743 
    L = ['%s=%r' % (key, value)
16744 
      for key, value in self.__dict__.iteritems()]
16745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16746 
 
16747 
  def __eq__(self, other):
16748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16749 
 
16750 
  def __ne__(self, other):
16751 
    return not (self == other)
16752 
 
16753 
class addOrUpdateBrandInfo_result:
16754 
 
16755 
  thrift_spec = (
16756 
  )
16757 
 
16758 
  def read(self, iprot):
16759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16761 
      return
16762 
    iprot.readStructBegin()
16763 
    while True:
16764 
      (fname, ftype, fid) = iprot.readFieldBegin()
16765 
      if ftype == TType.STOP:
16766 
        break
16767 
      else:
16768 
        iprot.skip(ftype)
16769 
      iprot.readFieldEnd()
16770 
    iprot.readStructEnd()
16771 
 
16772 
  def write(self, oprot):
16773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16775 
      return
16776 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16777 
    oprot.writeFieldStop()
16778 
    oprot.writeStructEnd()
16779 
 
16780 
  def validate(self):
16781 
    return
16782 
 
16783 
 
16784 
  def __repr__(self):
16785 
    L = ['%s=%r' % (key, value)
16786 
      for key, value in self.__dict__.iteritems()]
16787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16788 
 
16789 
  def __eq__(self, other):
16790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16791 
 
16792 
  def __ne__(self, other):
16793 
    return not (self == other)
16794 
 
16795 
class getBrandInfo_args:
16796 
 
16797 
  thrift_spec = (
16798 
  )
16799 
 
16800 
  def read(self, iprot):
16801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16803 
      return
16804 
    iprot.readStructBegin()
16805 
    while True:
16806 
      (fname, ftype, fid) = iprot.readFieldBegin()
16807 
      if ftype == TType.STOP:
16808 
        break
16809 
      else:
16810 
        iprot.skip(ftype)
16811 
      iprot.readFieldEnd()
16812 
    iprot.readStructEnd()
16813 
 
16814 
  def write(self, oprot):
16815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16817 
      return
16818 
    oprot.writeStructBegin('getBrandInfo_args')
16819 
    oprot.writeFieldStop()
16820 
    oprot.writeStructEnd()
16821 
 
16822 
  def validate(self):
16823 
    return
16824 
 
16825 
 
16826 
  def __repr__(self):
16827 
    L = ['%s=%r' % (key, value)
16828 
      for key, value in self.__dict__.iteritems()]
16829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16830 
 
16831 
  def __eq__(self, other):
16832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16833 
 
16834 
  def __ne__(self, other):
16835 
    return not (self == other)
16836 
 
16837 
class getBrandInfo_result:
16838 
  """
16839 
  Attributes:
16840 
   - success
16841 
  """
16842 
 
16843 
  thrift_spec = (
16844 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16845 
  )
16846 
 
16847 
  def __init__(self, success=None,):
16848 
    self.success = success
16849 
 
16850 
  def read(self, iprot):
16851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16853 
      return
16854 
    iprot.readStructBegin()
16855 
    while True:
16856 
      (fname, ftype, fid) = iprot.readFieldBegin()
16857 
      if ftype == TType.STOP:
16858 
        break
16859 
      if fid == 0:
16860 
        if ftype == TType.MAP:
16861 
          self.success = {}
7438 amit.gupta 16862 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16863 
          for _i318 in xrange(_size314):
16864 
            _key319 = iprot.readString();
16865 
            _val320 = BrandInfo()
16866 
            _val320.read(iprot)
16867 
            self.success[_key319] = _val320
7272 amit.gupta 16868 
          iprot.readMapEnd()
16869 
        else:
16870 
          iprot.skip(ftype)
16871 
      else:
16872 
        iprot.skip(ftype)
16873 
      iprot.readFieldEnd()
16874 
    iprot.readStructEnd()
16875 
 
16876 
  def write(self, oprot):
16877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16879 
      return
16880 
    oprot.writeStructBegin('getBrandInfo_result')
16881 
    if self.success is not None:
16882 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16883 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16884 
      for kiter321,viter322 in self.success.items():
16885 
        oprot.writeString(kiter321)
16886 
        viter322.write(oprot)
7272 amit.gupta 16887 
      oprot.writeMapEnd()
16888 
      oprot.writeFieldEnd()
16889 
    oprot.writeFieldStop()
16890 
    oprot.writeStructEnd()
16891 
 
16892 
  def validate(self):
16893 
    return
16894 
 
16895 
 
16896 
  def __repr__(self):
16897 
    L = ['%s=%r' % (key, value)
16898 
      for key, value in self.__dict__.iteritems()]
16899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16900 
 
16901 
  def __eq__(self, other):
16902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16903 
 
16904 
  def __ne__(self, other):
16905 
    return not (self == other)
16906 
 
7256 rajveer 16907 
class getStorePricing_args:
16908 
  """
16909 
  Attributes:
16910 
   - itemId
16911 
  """
16912 
 
16913 
  thrift_spec = (
16914 
    None, # 0
16915 
    (1, TType.I64, 'itemId', None, None, ), # 1
16916 
  )
16917 
 
16918 
  def __init__(self, itemId=None,):
16919 
    self.itemId = itemId
16920 
 
16921 
  def read(self, iprot):
16922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16924 
      return
16925 
    iprot.readStructBegin()
16926 
    while True:
16927 
      (fname, ftype, fid) = iprot.readFieldBegin()
16928 
      if ftype == TType.STOP:
16929 
        break
16930 
      if fid == 1:
16931 
        if ftype == TType.I64:
16932 
          self.itemId = iprot.readI64();
16933 
        else:
16934 
          iprot.skip(ftype)
16935 
      else:
16936 
        iprot.skip(ftype)
16937 
      iprot.readFieldEnd()
16938 
    iprot.readStructEnd()
16939 
 
16940 
  def write(self, oprot):
16941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16943 
      return
16944 
    oprot.writeStructBegin('getStorePricing_args')
16945 
    if self.itemId is not None:
16946 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16947 
      oprot.writeI64(self.itemId)
16948 
      oprot.writeFieldEnd()
16949 
    oprot.writeFieldStop()
16950 
    oprot.writeStructEnd()
16951 
 
16952 
  def validate(self):
16953 
    return
16954 
 
16955 
 
16956 
  def __repr__(self):
16957 
    L = ['%s=%r' % (key, value)
16958 
      for key, value in self.__dict__.iteritems()]
16959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16960 
 
16961 
  def __eq__(self, other):
16962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16963 
 
16964 
  def __ne__(self, other):
16965 
    return not (self == other)
16966 
 
16967 
class getStorePricing_result:
16968 
  """
16969 
  Attributes:
16970 
   - success
16971 
  """
16972 
 
16973 
  thrift_spec = (
16974 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16975 
  )
16976 
 
16977 
  def __init__(self, success=None,):
16978 
    self.success = success
16979 
 
16980 
  def read(self, iprot):
16981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16983 
      return
16984 
    iprot.readStructBegin()
16985 
    while True:
16986 
      (fname, ftype, fid) = iprot.readFieldBegin()
16987 
      if ftype == TType.STOP:
16988 
        break
16989 
      if fid == 0:
16990 
        if ftype == TType.STRUCT:
16991 
          self.success = StorePricing()
16992 
          self.success.read(iprot)
16993 
        else:
16994 
          iprot.skip(ftype)
16995 
      else:
16996 
        iprot.skip(ftype)
16997 
      iprot.readFieldEnd()
16998 
    iprot.readStructEnd()
16999 
 
17000 
  def write(self, oprot):
17001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17003 
      return
17004 
    oprot.writeStructBegin('getStorePricing_result')
17005 
    if self.success is not None:
17006 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17007 
      self.success.write(oprot)
17008 
      oprot.writeFieldEnd()
17009 
    oprot.writeFieldStop()
17010 
    oprot.writeStructEnd()
17011 
 
17012 
  def validate(self):
17013 
    return
17014 
 
17015 
 
17016 
  def __repr__(self):
17017 
    L = ['%s=%r' % (key, value)
17018 
      for key, value in self.__dict__.iteritems()]
17019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17020 
 
17021 
  def __eq__(self, other):
17022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17023 
 
17024 
  def __ne__(self, other):
17025 
    return not (self == other)
7265 rajveer 17026 
 
7306 rajveer 17027 
class getStorePricings_args:
17028 
  """
17029 
  Attributes:
17030 
   - itemIds
17031 
  """
17032 
 
17033 
  thrift_spec = (
17034 
    None, # 0
17035 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17036 
  )
17037 
 
17038 
  def __init__(self, itemIds=None,):
17039 
    self.itemIds = itemIds
17040 
 
17041 
  def read(self, iprot):
17042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17044 
      return
17045 
    iprot.readStructBegin()
17046 
    while True:
17047 
      (fname, ftype, fid) = iprot.readFieldBegin()
17048 
      if ftype == TType.STOP:
17049 
        break
17050 
      if fid == 1:
17051 
        if ftype == TType.LIST:
17052 
          self.itemIds = []
7438 amit.gupta 17053 
          (_etype326, _size323) = iprot.readListBegin()
17054 
          for _i327 in xrange(_size323):
17055 
            _elem328 = iprot.readI64();
17056 
            self.itemIds.append(_elem328)
7306 rajveer 17057 
          iprot.readListEnd()
17058 
        else:
17059 
          iprot.skip(ftype)
17060 
      else:
17061 
        iprot.skip(ftype)
17062 
      iprot.readFieldEnd()
17063 
    iprot.readStructEnd()
17064 
 
17065 
  def write(self, oprot):
17066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17068 
      return
17069 
    oprot.writeStructBegin('getStorePricings_args')
17070 
    if self.itemIds is not None:
17071 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17072 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 17073 
      for iter329 in self.itemIds:
17074 
        oprot.writeI64(iter329)
7306 rajveer 17075 
      oprot.writeListEnd()
17076 
      oprot.writeFieldEnd()
17077 
    oprot.writeFieldStop()
17078 
    oprot.writeStructEnd()
17079 
 
17080 
  def validate(self):
17081 
    return
17082 
 
17083 
 
17084 
  def __repr__(self):
17085 
    L = ['%s=%r' % (key, value)
17086 
      for key, value in self.__dict__.iteritems()]
17087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17088 
 
17089 
  def __eq__(self, other):
17090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17091 
 
17092 
  def __ne__(self, other):
17093 
    return not (self == other)
17094 
 
17095 
class getStorePricings_result:
17096 
  """
17097 
  Attributes:
17098 
   - success
17099 
  """
17100 
 
17101 
  thrift_spec = (
17102 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
17103 
  )
17104 
 
17105 
  def __init__(self, success=None,):
17106 
    self.success = success
17107 
 
17108 
  def read(self, iprot):
17109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17111 
      return
17112 
    iprot.readStructBegin()
17113 
    while True:
17114 
      (fname, ftype, fid) = iprot.readFieldBegin()
17115 
      if ftype == TType.STOP:
17116 
        break
17117 
      if fid == 0:
17118 
        if ftype == TType.LIST:
17119 
          self.success = []
7438 amit.gupta 17120 
          (_etype333, _size330) = iprot.readListBegin()
17121 
          for _i334 in xrange(_size330):
17122 
            _elem335 = StorePricing()
17123 
            _elem335.read(iprot)
17124 
            self.success.append(_elem335)
7306 rajveer 17125 
          iprot.readListEnd()
17126 
        else:
17127 
          iprot.skip(ftype)
17128 
      else:
17129 
        iprot.skip(ftype)
17130 
      iprot.readFieldEnd()
17131 
    iprot.readStructEnd()
17132 
 
17133 
  def write(self, oprot):
17134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17136 
      return
17137 
    oprot.writeStructBegin('getStorePricings_result')
17138 
    if self.success is not None:
17139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17141 
      for iter336 in self.success:
17142 
        iter336.write(oprot)
7306 rajveer 17143 
      oprot.writeListEnd()
17144 
      oprot.writeFieldEnd()
17145 
    oprot.writeFieldStop()
17146 
    oprot.writeStructEnd()
17147 
 
17148 
  def validate(self):
17149 
    return
17150 
 
17151 
 
17152 
  def __repr__(self):
17153 
    L = ['%s=%r' % (key, value)
17154 
      for key, value in self.__dict__.iteritems()]
17155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17156 
 
17157 
  def __eq__(self, other):
17158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17159 
 
17160 
  def __ne__(self, other):
17161 
    return not (self == other)
17162 
 
7265 rajveer 17163 
class updateStorePricing_args:
17164 
  """
17165 
  Attributes:
17166 
   - sp
7382 rajveer 17167 
   - allColors
7265 rajveer 17168 
  """
17169 
 
17170 
  thrift_spec = (
17171 
    None, # 0
17172 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 17173 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 17174 
  )
17175 
 
7382 rajveer 17176 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 17177 
    self.sp = sp
7382 rajveer 17178 
    self.allColors = allColors
7265 rajveer 17179 
 
17180 
  def read(self, iprot):
17181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17183 
      return
17184 
    iprot.readStructBegin()
17185 
    while True:
17186 
      (fname, ftype, fid) = iprot.readFieldBegin()
17187 
      if ftype == TType.STOP:
17188 
        break
17189 
      if fid == 1:
17190 
        if ftype == TType.STRUCT:
17191 
          self.sp = StorePricing()
17192 
          self.sp.read(iprot)
17193 
        else:
17194 
          iprot.skip(ftype)
7382 rajveer 17195 
      elif fid == 2:
17196 
        if ftype == TType.BOOL:
17197 
          self.allColors = iprot.readBool();
17198 
        else:
17199 
          iprot.skip(ftype)
7265 rajveer 17200 
      else:
17201 
        iprot.skip(ftype)
17202 
      iprot.readFieldEnd()
17203 
    iprot.readStructEnd()
17204 
 
17205 
  def write(self, oprot):
17206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17208 
      return
17209 
    oprot.writeStructBegin('updateStorePricing_args')
17210 
    if self.sp is not None:
17211 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
17212 
      self.sp.write(oprot)
17213 
      oprot.writeFieldEnd()
7382 rajveer 17214 
    if self.allColors is not None:
17215 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
17216 
      oprot.writeBool(self.allColors)
17217 
      oprot.writeFieldEnd()
7265 rajveer 17218 
    oprot.writeFieldStop()
17219 
    oprot.writeStructEnd()
17220 
 
17221 
  def validate(self):
17222 
    return
17223 
 
17224 
 
17225 
  def __repr__(self):
17226 
    L = ['%s=%r' % (key, value)
17227 
      for key, value in self.__dict__.iteritems()]
17228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17229 
 
17230 
  def __eq__(self, other):
17231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17232 
 
17233 
  def __ne__(self, other):
17234 
    return not (self == other)
17235 
 
17236 
class updateStorePricing_result:
17237 
 
17238 
  thrift_spec = (
17239 
  )
17240 
 
17241 
  def read(self, iprot):
17242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17244 
      return
17245 
    iprot.readStructBegin()
17246 
    while True:
17247 
      (fname, ftype, fid) = iprot.readFieldBegin()
17248 
      if ftype == TType.STOP:
17249 
        break
17250 
      else:
17251 
        iprot.skip(ftype)
17252 
      iprot.readFieldEnd()
17253 
    iprot.readStructEnd()
17254 
 
17255 
  def write(self, oprot):
17256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17258 
      return
17259 
    oprot.writeStructBegin('updateStorePricing_result')
17260 
    oprot.writeFieldStop()
17261 
    oprot.writeStructEnd()
17262 
 
17263 
  def validate(self):
17264 
    return
17265 
 
17266 
 
17267 
  def __repr__(self):
17268 
    L = ['%s=%r' % (key, value)
17269 
      for key, value in self.__dict__.iteritems()]
17270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17271 
 
17272 
  def __eq__(self, other):
17273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17274 
 
17275 
  def __ne__(self, other):
17276 
    return not (self == other)
7281 kshitij.so 17277 
 
17278 
class getAllAmazonListedItems_args:
17279 
 
17280 
  thrift_spec = (
17281 
  )
17282 
 
17283 
  def read(self, iprot):
17284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17286 
      return
17287 
    iprot.readStructBegin()
17288 
    while True:
17289 
      (fname, ftype, fid) = iprot.readFieldBegin()
17290 
      if ftype == TType.STOP:
17291 
        break
17292 
      else:
17293 
        iprot.skip(ftype)
17294 
      iprot.readFieldEnd()
17295 
    iprot.readStructEnd()
17296 
 
17297 
  def write(self, oprot):
17298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17300 
      return
17301 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17302 
    oprot.writeFieldStop()
17303 
    oprot.writeStructEnd()
17304 
 
17305 
  def validate(self):
17306 
    return
17307 
 
17308 
 
17309 
  def __repr__(self):
17310 
    L = ['%s=%r' % (key, value)
17311 
      for key, value in self.__dict__.iteritems()]
17312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17313 
 
17314 
  def __eq__(self, other):
17315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17316 
 
17317 
  def __ne__(self, other):
17318 
    return not (self == other)
17319 
 
17320 
class getAllAmazonListedItems_result:
17321 
  """
17322 
  Attributes:
17323 
   - success
17324 
  """
17325 
 
17326 
  thrift_spec = (
17327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17328 
  )
17329 
 
17330 
  def __init__(self, success=None,):
17331 
    self.success = success
17332 
 
17333 
  def read(self, iprot):
17334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17336 
      return
17337 
    iprot.readStructBegin()
17338 
    while True:
17339 
      (fname, ftype, fid) = iprot.readFieldBegin()
17340 
      if ftype == TType.STOP:
17341 
        break
17342 
      if fid == 0:
17343 
        if ftype == TType.LIST:
17344 
          self.success = []
7438 amit.gupta 17345 
          (_etype340, _size337) = iprot.readListBegin()
17346 
          for _i341 in xrange(_size337):
17347 
            _elem342 = Amazonlisted()
17348 
            _elem342.read(iprot)
17349 
            self.success.append(_elem342)
7281 kshitij.so 17350 
          iprot.readListEnd()
17351 
        else:
17352 
          iprot.skip(ftype)
17353 
      else:
17354 
        iprot.skip(ftype)
17355 
      iprot.readFieldEnd()
17356 
    iprot.readStructEnd()
17357 
 
17358 
  def write(self, oprot):
17359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17361 
      return
17362 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17363 
    if self.success is not None:
17364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17366 
      for iter343 in self.success:
17367 
        iter343.write(oprot)
7281 kshitij.so 17368 
      oprot.writeListEnd()
17369 
      oprot.writeFieldEnd()
17370 
    oprot.writeFieldStop()
17371 
    oprot.writeStructEnd()
17372 
 
17373 
  def validate(self):
17374 
    return
17375 
 
17376 
 
17377 
  def __repr__(self):
17378 
    L = ['%s=%r' % (key, value)
17379 
      for key, value in self.__dict__.iteritems()]
17380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17381 
 
17382 
  def __eq__(self, other):
17383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17384 
 
17385 
  def __ne__(self, other):
17386 
    return not (self == other)
17387 
 
17388 
class getAmazonItemDetails_args:
17389 
  """
17390 
  Attributes:
17391 
   - itemId
17392 
  """
17393 
 
17394 
  thrift_spec = (
17395 
    None, # 0
17396 
    (1, TType.I64, 'itemId', None, None, ), # 1
17397 
  )
17398 
 
17399 
  def __init__(self, itemId=None,):
17400 
    self.itemId = itemId
17401 
 
17402 
  def read(self, iprot):
17403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17405 
      return
17406 
    iprot.readStructBegin()
17407 
    while True:
17408 
      (fname, ftype, fid) = iprot.readFieldBegin()
17409 
      if ftype == TType.STOP:
17410 
        break
17411 
      if fid == 1:
17412 
        if ftype == TType.I64:
17413 
          self.itemId = iprot.readI64();
17414 
        else:
17415 
          iprot.skip(ftype)
17416 
      else:
17417 
        iprot.skip(ftype)
17418 
      iprot.readFieldEnd()
17419 
    iprot.readStructEnd()
17420 
 
17421 
  def write(self, oprot):
17422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17424 
      return
17425 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17426 
    if self.itemId is not None:
17427 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17428 
      oprot.writeI64(self.itemId)
17429 
      oprot.writeFieldEnd()
17430 
    oprot.writeFieldStop()
17431 
    oprot.writeStructEnd()
17432 
 
17433 
  def validate(self):
17434 
    return
17435 
 
17436 
 
17437 
  def __repr__(self):
17438 
    L = ['%s=%r' % (key, value)
17439 
      for key, value in self.__dict__.iteritems()]
17440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17441 
 
17442 
  def __eq__(self, other):
17443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17444 
 
17445 
  def __ne__(self, other):
17446 
    return not (self == other)
17447 
 
17448 
class getAmazonItemDetails_result:
17449 
  """
17450 
  Attributes:
17451 
   - success
17452 
  """
17453 
 
17454 
  thrift_spec = (
17455 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17456 
  )
17457 
 
17458 
  def __init__(self, success=None,):
17459 
    self.success = success
17460 
 
17461 
  def read(self, iprot):
17462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17464 
      return
17465 
    iprot.readStructBegin()
17466 
    while True:
17467 
      (fname, ftype, fid) = iprot.readFieldBegin()
17468 
      if ftype == TType.STOP:
17469 
        break
17470 
      if fid == 0:
17471 
        if ftype == TType.STRUCT:
17472 
          self.success = Amazonlisted()
17473 
          self.success.read(iprot)
17474 
        else:
17475 
          iprot.skip(ftype)
17476 
      else:
17477 
        iprot.skip(ftype)
17478 
      iprot.readFieldEnd()
17479 
    iprot.readStructEnd()
17480 
 
17481 
  def write(self, oprot):
17482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17484 
      return
17485 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17486 
    if self.success is not None:
17487 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17488 
      self.success.write(oprot)
17489 
      oprot.writeFieldEnd()
17490 
    oprot.writeFieldStop()
17491 
    oprot.writeStructEnd()
17492 
 
17493 
  def validate(self):
17494 
    return
17495 
 
17496 
 
17497 
  def __repr__(self):
17498 
    L = ['%s=%r' % (key, value)
17499 
      for key, value in self.__dict__.iteritems()]
17500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17501 
 
17502 
  def __eq__(self, other):
17503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17504 
 
17505 
  def __ne__(self, other):
17506 
    return not (self == other)
17507 
 
17508 
class updateAmazonItemDetails_args:
17509 
  """
17510 
  Attributes:
8168 kshitij.so 17511 
   - amazonlisted
7281 kshitij.so 17512 
  """
17513 
 
17514 
  thrift_spec = (
17515 
    None, # 0
8168 kshitij.so 17516 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 17517 
  )
17518 
 
8168 kshitij.so 17519 
  def __init__(self, amazonlisted=None,):
17520 
    self.amazonlisted = amazonlisted
7281 kshitij.so 17521 
 
17522 
  def read(self, iprot):
17523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17525 
      return
17526 
    iprot.readStructBegin()
17527 
    while True:
17528 
      (fname, ftype, fid) = iprot.readFieldBegin()
17529 
      if ftype == TType.STOP:
17530 
        break
17531 
      if fid == 1:
8168 kshitij.so 17532 
        if ftype == TType.STRUCT:
17533 
          self.amazonlisted = Amazonlisted()
17534 
          self.amazonlisted.read(iprot)
7281 kshitij.so 17535 
        else:
17536 
          iprot.skip(ftype)
17537 
      else:
17538 
        iprot.skip(ftype)
17539 
      iprot.readFieldEnd()
17540 
    iprot.readStructEnd()
17541 
 
17542 
  def write(self, oprot):
17543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17545 
      return
17546 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 17547 
    if self.amazonlisted is not None:
17548 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17549 
      self.amazonlisted.write(oprot)
7281 kshitij.so 17550 
      oprot.writeFieldEnd()
17551 
    oprot.writeFieldStop()
17552 
    oprot.writeStructEnd()
17553 
 
17554 
  def validate(self):
17555 
    return
17556 
 
17557 
 
17558 
  def __repr__(self):
17559 
    L = ['%s=%r' % (key, value)
17560 
      for key, value in self.__dict__.iteritems()]
17561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17562 
 
17563 
  def __eq__(self, other):
17564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17565 
 
17566 
  def __ne__(self, other):
17567 
    return not (self == other)
17568 
 
17569 
class updateAmazonItemDetails_result:
17570 
 
17571 
  thrift_spec = (
17572 
  )
17573 
 
17574 
  def read(self, iprot):
17575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17577 
      return
17578 
    iprot.readStructBegin()
17579 
    while True:
17580 
      (fname, ftype, fid) = iprot.readFieldBegin()
17581 
      if ftype == TType.STOP:
17582 
        break
17583 
      else:
17584 
        iprot.skip(ftype)
17585 
      iprot.readFieldEnd()
17586 
    iprot.readStructEnd()
17587 
 
17588 
  def write(self, oprot):
17589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17591 
      return
17592 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17593 
    oprot.writeFieldStop()
17594 
    oprot.writeStructEnd()
17595 
 
17596 
  def validate(self):
17597 
    return
17598 
 
17599 
 
17600 
  def __repr__(self):
17601 
    L = ['%s=%r' % (key, value)
17602 
      for key, value in self.__dict__.iteritems()]
17603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17604 
 
17605 
  def __eq__(self, other):
17606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17607 
 
17608 
  def __ne__(self, other):
17609 
    return not (self == other)
17610 
 
17611 
class addAmazonItem_args:
17612 
  """
17613 
  Attributes:
17614 
   - amazonlisted
17615 
  """
17616 
 
17617 
  thrift_spec = (
17618 
    None, # 0
17619 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17620 
  )
17621 
 
17622 
  def __init__(self, amazonlisted=None,):
17623 
    self.amazonlisted = amazonlisted
17624 
 
17625 
  def read(self, iprot):
17626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17628 
      return
17629 
    iprot.readStructBegin()
17630 
    while True:
17631 
      (fname, ftype, fid) = iprot.readFieldBegin()
17632 
      if ftype == TType.STOP:
17633 
        break
17634 
      if fid == 1:
17635 
        if ftype == TType.STRUCT:
17636 
          self.amazonlisted = Amazonlisted()
17637 
          self.amazonlisted.read(iprot)
17638 
        else:
17639 
          iprot.skip(ftype)
17640 
      else:
17641 
        iprot.skip(ftype)
17642 
      iprot.readFieldEnd()
17643 
    iprot.readStructEnd()
17644 
 
17645 
  def write(self, oprot):
17646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17648 
      return
17649 
    oprot.writeStructBegin('addAmazonItem_args')
17650 
    if self.amazonlisted is not None:
17651 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17652 
      self.amazonlisted.write(oprot)
17653 
      oprot.writeFieldEnd()
17654 
    oprot.writeFieldStop()
17655 
    oprot.writeStructEnd()
17656 
 
17657 
  def validate(self):
17658 
    return
17659 
 
17660 
 
17661 
  def __repr__(self):
17662 
    L = ['%s=%r' % (key, value)
17663 
      for key, value in self.__dict__.iteritems()]
17664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17665 
 
17666 
  def __eq__(self, other):
17667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17668 
 
17669 
  def __ne__(self, other):
17670 
    return not (self == other)
17671 
 
17672 
class addAmazonItem_result:
17673 
 
17674 
  thrift_spec = (
17675 
  )
17676 
 
17677 
  def read(self, iprot):
17678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17680 
      return
17681 
    iprot.readStructBegin()
17682 
    while True:
17683 
      (fname, ftype, fid) = iprot.readFieldBegin()
17684 
      if ftype == TType.STOP:
17685 
        break
17686 
      else:
17687 
        iprot.skip(ftype)
17688 
      iprot.readFieldEnd()
17689 
    iprot.readStructEnd()
17690 
 
17691 
  def write(self, oprot):
17692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17694 
      return
17695 
    oprot.writeStructBegin('addAmazonItem_result')
17696 
    oprot.writeFieldStop()
17697 
    oprot.writeStructEnd()
17698 
 
17699 
  def validate(self):
17700 
    return
17701 
 
17702 
 
17703 
  def __repr__(self):
17704 
    L = ['%s=%r' % (key, value)
17705 
      for key, value in self.__dict__.iteritems()]
17706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17707 
 
17708 
  def __eq__(self, other):
17709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17710 
 
17711 
  def __ne__(self, other):
17712 
    return not (self == other)
7291 vikram.rag 17713 
 
17714 
class getAsinItems_args:
17715 
 
17716 
  thrift_spec = (
17717 
  )
17718 
 
17719 
  def read(self, iprot):
17720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17722 
      return
17723 
    iprot.readStructBegin()
17724 
    while True:
17725 
      (fname, ftype, fid) = iprot.readFieldBegin()
17726 
      if ftype == TType.STOP:
17727 
        break
17728 
      else:
17729 
        iprot.skip(ftype)
17730 
      iprot.readFieldEnd()
17731 
    iprot.readStructEnd()
17732 
 
17733 
  def write(self, oprot):
17734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17736 
      return
17737 
    oprot.writeStructBegin('getAsinItems_args')
17738 
    oprot.writeFieldStop()
17739 
    oprot.writeStructEnd()
17740 
 
17741 
  def validate(self):
17742 
    return
17743 
 
17744 
 
17745 
  def __repr__(self):
17746 
    L = ['%s=%r' % (key, value)
17747 
      for key, value in self.__dict__.iteritems()]
17748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17749 
 
17750 
  def __eq__(self, other):
17751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17752 
 
17753 
  def __ne__(self, other):
17754 
    return not (self == other)
17755 
 
17756 
class getAsinItems_result:
17757 
  """
17758 
  Attributes:
17759 
   - success
17760 
  """
17761 
 
17762 
  thrift_spec = (
17763 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17764 
  )
17765 
 
17766 
  def __init__(self, success=None,):
17767 
    self.success = success
17768 
 
17769 
  def read(self, iprot):
17770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17772 
      return
17773 
    iprot.readStructBegin()
17774 
    while True:
17775 
      (fname, ftype, fid) = iprot.readFieldBegin()
17776 
      if ftype == TType.STOP:
17777 
        break
17778 
      if fid == 0:
17779 
        if ftype == TType.LIST:
17780 
          self.success = []
7438 amit.gupta 17781 
          (_etype347, _size344) = iprot.readListBegin()
17782 
          for _i348 in xrange(_size344):
17783 
            _elem349 = Item()
17784 
            _elem349.read(iprot)
17785 
            self.success.append(_elem349)
7291 vikram.rag 17786 
          iprot.readListEnd()
17787 
        else:
17788 
          iprot.skip(ftype)
17789 
      else:
17790 
        iprot.skip(ftype)
17791 
      iprot.readFieldEnd()
17792 
    iprot.readStructEnd()
17793 
 
17794 
  def write(self, oprot):
17795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17797 
      return
17798 
    oprot.writeStructBegin('getAsinItems_result')
17799 
    if self.success is not None:
17800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17802 
      for iter350 in self.success:
17803 
        iter350.write(oprot)
7291 vikram.rag 17804 
      oprot.writeListEnd()
17805 
      oprot.writeFieldEnd()
17806 
    oprot.writeFieldStop()
17807 
    oprot.writeStructEnd()
17808 
 
17809 
  def validate(self):
17810 
    return
17811 
 
17812 
 
17813 
  def __repr__(self):
17814 
    L = ['%s=%r' % (key, value)
17815 
      for key, value in self.__dict__.iteritems()]
17816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17817 
 
17818 
  def __eq__(self, other):
17819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17820 
 
17821 
  def __ne__(self, other):
17822 
    return not (self == other)
17823 
 
17824 
class getAllFbaListedItems_args:
17825 
 
17826 
  thrift_spec = (
17827 
  )
17828 
 
17829 
  def read(self, iprot):
17830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17832 
      return
17833 
    iprot.readStructBegin()
17834 
    while True:
17835 
      (fname, ftype, fid) = iprot.readFieldBegin()
17836 
      if ftype == TType.STOP:
17837 
        break
17838 
      else:
17839 
        iprot.skip(ftype)
17840 
      iprot.readFieldEnd()
17841 
    iprot.readStructEnd()
17842 
 
17843 
  def write(self, oprot):
17844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17846 
      return
17847 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17848 
    oprot.writeFieldStop()
17849 
    oprot.writeStructEnd()
17850 
 
17851 
  def validate(self):
17852 
    return
17853 
 
17854 
 
17855 
  def __repr__(self):
17856 
    L = ['%s=%r' % (key, value)
17857 
      for key, value in self.__dict__.iteritems()]
17858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17859 
 
17860 
  def __eq__(self, other):
17861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17862 
 
17863 
  def __ne__(self, other):
17864 
    return not (self == other)
17865 
 
17866 
class getAllFbaListedItems_result:
17867 
  """
17868 
  Attributes:
17869 
   - success
17870 
  """
17871 
 
17872 
  thrift_spec = (
17873 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17874 
  )
17875 
 
17876 
  def __init__(self, success=None,):
17877 
    self.success = success
17878 
 
17879 
  def read(self, iprot):
17880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17882 
      return
17883 
    iprot.readStructBegin()
17884 
    while True:
17885 
      (fname, ftype, fid) = iprot.readFieldBegin()
17886 
      if ftype == TType.STOP:
17887 
        break
17888 
      if fid == 0:
17889 
        if ftype == TType.LIST:
17890 
          self.success = []
7438 amit.gupta 17891 
          (_etype354, _size351) = iprot.readListBegin()
17892 
          for _i355 in xrange(_size351):
17893 
            _elem356 = Amazonlisted()
17894 
            _elem356.read(iprot)
17895 
            self.success.append(_elem356)
7291 vikram.rag 17896 
          iprot.readListEnd()
17897 
        else:
17898 
          iprot.skip(ftype)
17899 
      else:
17900 
        iprot.skip(ftype)
17901 
      iprot.readFieldEnd()
17902 
    iprot.readStructEnd()
17903 
 
17904 
  def write(self, oprot):
17905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17907 
      return
17908 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17909 
    if self.success is not None:
17910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17911 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17912 
      for iter357 in self.success:
17913 
        iter357.write(oprot)
7291 vikram.rag 17914 
      oprot.writeListEnd()
17915 
      oprot.writeFieldEnd()
17916 
    oprot.writeFieldStop()
17917 
    oprot.writeStructEnd()
17918 
 
17919 
  def validate(self):
17920 
    return
17921 
 
17922 
 
17923 
  def __repr__(self):
17924 
    L = ['%s=%r' % (key, value)
17925 
      for key, value in self.__dict__.iteritems()]
17926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17927 
 
17928 
  def __eq__(self, other):
17929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17930 
 
17931 
  def __ne__(self, other):
17932 
    return not (self == other)
17933 
 
17934 
class getAllNonFbaListedItems_args:
17935 
 
17936 
  thrift_spec = (
17937 
  )
17938 
 
17939 
  def read(self, iprot):
17940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17942 
      return
17943 
    iprot.readStructBegin()
17944 
    while True:
17945 
      (fname, ftype, fid) = iprot.readFieldBegin()
17946 
      if ftype == TType.STOP:
17947 
        break
17948 
      else:
17949 
        iprot.skip(ftype)
17950 
      iprot.readFieldEnd()
17951 
    iprot.readStructEnd()
17952 
 
17953 
  def write(self, oprot):
17954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17956 
      return
17957 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17958 
    oprot.writeFieldStop()
17959 
    oprot.writeStructEnd()
17960 
 
17961 
  def validate(self):
17962 
    return
17963 
 
17964 
 
17965 
  def __repr__(self):
17966 
    L = ['%s=%r' % (key, value)
17967 
      for key, value in self.__dict__.iteritems()]
17968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17969 
 
17970 
  def __eq__(self, other):
17971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17972 
 
17973 
  def __ne__(self, other):
17974 
    return not (self == other)
17975 
 
17976 
class getAllNonFbaListedItems_result:
17977 
  """
17978 
  Attributes:
17979 
   - success
17980 
  """
17981 
 
17982 
  thrift_spec = (
17983 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17984 
  )
17985 
 
17986 
  def __init__(self, success=None,):
17987 
    self.success = success
17988 
 
17989 
  def read(self, iprot):
17990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17992 
      return
17993 
    iprot.readStructBegin()
17994 
    while True:
17995 
      (fname, ftype, fid) = iprot.readFieldBegin()
17996 
      if ftype == TType.STOP:
17997 
        break
17998 
      if fid == 0:
17999 
        if ftype == TType.LIST:
18000 
          self.success = []
7438 amit.gupta 18001 
          (_etype361, _size358) = iprot.readListBegin()
18002 
          for _i362 in xrange(_size358):
18003 
            _elem363 = Amazonlisted()
18004 
            _elem363.read(iprot)
18005 
            self.success.append(_elem363)
7291 vikram.rag 18006 
          iprot.readListEnd()
18007 
        else:
18008 
          iprot.skip(ftype)
18009 
      else:
18010 
        iprot.skip(ftype)
18011 
      iprot.readFieldEnd()
18012 
    iprot.readStructEnd()
18013 
 
18014 
  def write(self, oprot):
18015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18017 
      return
18018 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
18019 
    if self.success is not None:
18020 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18021 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18022 
      for iter364 in self.success:
18023 
        iter364.write(oprot)
7291 vikram.rag 18024 
      oprot.writeListEnd()
18025 
      oprot.writeFieldEnd()
18026 
    oprot.writeFieldStop()
18027 
    oprot.writeStructEnd()
18028 
 
18029 
  def validate(self):
18030 
    return
18031 
 
18032 
 
18033 
  def __repr__(self):
18034 
    L = ['%s=%r' % (key, value)
18035 
      for key, value in self.__dict__.iteritems()]
18036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18037 
 
18038 
  def __eq__(self, other):
18039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18040 
 
18041 
  def __ne__(self, other):
18042 
    return not (self == other)
7460 kshitij.so 18043 
 
18044 
class updateItemInventory_args:
18045 
  """
18046 
  Attributes:
18047 
   - itemId
18048 
   - holdInventory
18049 
   - defaultInventory
18050 
  """
18051 
 
18052 
  thrift_spec = (
18053 
    None, # 0
18054 
    (1, TType.I64, 'itemId', None, None, ), # 1
18055 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
18056 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
18057 
  )
18058 
 
18059 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
18060 
    self.itemId = itemId
18061 
    self.holdInventory = holdInventory
18062 
    self.defaultInventory = defaultInventory
18063 
 
18064 
  def read(self, iprot):
18065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18067 
      return
18068 
    iprot.readStructBegin()
18069 
    while True:
18070 
      (fname, ftype, fid) = iprot.readFieldBegin()
18071 
      if ftype == TType.STOP:
18072 
        break
18073 
      if fid == 1:
18074 
        if ftype == TType.I64:
18075 
          self.itemId = iprot.readI64();
18076 
        else:
18077 
          iprot.skip(ftype)
18078 
      elif fid == 2:
18079 
        if ftype == TType.I64:
18080 
          self.holdInventory = iprot.readI64();
18081 
        else:
18082 
          iprot.skip(ftype)
18083 
      elif fid == 3:
18084 
        if ftype == TType.I64:
18085 
          self.defaultInventory = iprot.readI64();
18086 
        else:
18087 
          iprot.skip(ftype)
18088 
      else:
18089 
        iprot.skip(ftype)
18090 
      iprot.readFieldEnd()
18091 
    iprot.readStructEnd()
18092 
 
18093 
  def write(self, oprot):
18094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18096 
      return
18097 
    oprot.writeStructBegin('updateItemInventory_args')
18098 
    if self.itemId is not None:
18099 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18100 
      oprot.writeI64(self.itemId)
18101 
      oprot.writeFieldEnd()
18102 
    if self.holdInventory is not None:
18103 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
18104 
      oprot.writeI64(self.holdInventory)
18105 
      oprot.writeFieldEnd()
18106 
    if self.defaultInventory is not None:
18107 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
18108 
      oprot.writeI64(self.defaultInventory)
18109 
      oprot.writeFieldEnd()
18110 
    oprot.writeFieldStop()
18111 
    oprot.writeStructEnd()
18112 
 
18113 
  def validate(self):
18114 
    return
18115 
 
18116 
 
18117 
  def __repr__(self):
18118 
    L = ['%s=%r' % (key, value)
18119 
      for key, value in self.__dict__.iteritems()]
18120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18121 
 
18122 
  def __eq__(self, other):
18123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18124 
 
18125 
  def __ne__(self, other):
18126 
    return not (self == other)
18127 
 
18128 
class updateItemInventory_result:
18129 
  """
18130 
  Attributes:
18131 
   - success
18132 
  """
18133 
 
18134 
  thrift_spec = (
18135 
    (0, TType.BOOL, 'success', None, None, ), # 0
18136 
  )
18137 
 
18138 
  def __init__(self, success=None,):
18139 
    self.success = success
18140 
 
18141 
  def read(self, iprot):
18142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18144 
      return
18145 
    iprot.readStructBegin()
18146 
    while True:
18147 
      (fname, ftype, fid) = iprot.readFieldBegin()
18148 
      if ftype == TType.STOP:
18149 
        break
18150 
      if fid == 0:
18151 
        if ftype == TType.BOOL:
18152 
          self.success = iprot.readBool();
18153 
        else:
18154 
          iprot.skip(ftype)
18155 
      else:
18156 
        iprot.skip(ftype)
18157 
      iprot.readFieldEnd()
18158 
    iprot.readStructEnd()
18159 
 
18160 
  def write(self, oprot):
18161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18163 
      return
18164 
    oprot.writeStructBegin('updateItemInventory_result')
18165 
    if self.success is not None:
18166 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18167 
      oprot.writeBool(self.success)
18168 
      oprot.writeFieldEnd()
18169 
    oprot.writeFieldStop()
18170 
    oprot.writeStructEnd()
18171 
 
18172 
  def validate(self):
18173 
    return
18174 
 
18175 
 
18176 
  def __repr__(self):
18177 
    L = ['%s=%r' % (key, value)
18178 
      for key, value in self.__dict__.iteritems()]
18179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18180 
 
18181 
  def __eq__(self, other):
18182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18183 
 
18184 
  def __ne__(self, other):
18185 
    return not (self == other)
7770 kshitij.so 18186 
 
18187 
class updateTimestampForAmazonFeeds_args:
18188 
  """
18189 
  Attributes:
18190 
   - type
18191 
   - sku
18192 
   - timestamp
18193 
  """
18194 
 
18195 
  thrift_spec = (
18196 
    None, # 0
18197 
    (1, TType.STRING, 'type', None, None, ), # 1
18198 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18199 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18200 
  )
18201 
 
18202 
  def __init__(self, type=None, sku=None, timestamp=None,):
18203 
    self.type = type
18204 
    self.sku = sku
18205 
    self.timestamp = timestamp
18206 
 
18207 
  def read(self, iprot):
18208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18210 
      return
18211 
    iprot.readStructBegin()
18212 
    while True:
18213 
      (fname, ftype, fid) = iprot.readFieldBegin()
18214 
      if ftype == TType.STOP:
18215 
        break
18216 
      if fid == 1:
18217 
        if ftype == TType.STRING:
18218 
          self.type = iprot.readString();
18219 
        else:
18220 
          iprot.skip(ftype)
18221 
      elif fid == 2:
18222 
        if ftype == TType.LIST:
18223 
          self.sku = []
18224 
          (_etype368, _size365) = iprot.readListBegin()
18225 
          for _i369 in xrange(_size365):
18226 
            _elem370 = iprot.readI64();
18227 
            self.sku.append(_elem370)
18228 
          iprot.readListEnd()
18229 
        else:
18230 
          iprot.skip(ftype)
18231 
      elif fid == 3:
18232 
        if ftype == TType.I64:
18233 
          self.timestamp = iprot.readI64();
18234 
        else:
18235 
          iprot.skip(ftype)
18236 
      else:
18237 
        iprot.skip(ftype)
18238 
      iprot.readFieldEnd()
18239 
    iprot.readStructEnd()
18240 
 
18241 
  def write(self, oprot):
18242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18244 
      return
18245 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18246 
    if self.type is not None:
18247 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18248 
      oprot.writeString(self.type)
18249 
      oprot.writeFieldEnd()
18250 
    if self.sku is not None:
18251 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18252 
      oprot.writeListBegin(TType.I64, len(self.sku))
18253 
      for iter371 in self.sku:
18254 
        oprot.writeI64(iter371)
18255 
      oprot.writeListEnd()
18256 
      oprot.writeFieldEnd()
18257 
    if self.timestamp is not None:
18258 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18259 
      oprot.writeI64(self.timestamp)
18260 
      oprot.writeFieldEnd()
18261 
    oprot.writeFieldStop()
18262 
    oprot.writeStructEnd()
18263 
 
18264 
  def validate(self):
18265 
    return
18266 
 
18267 
 
18268 
  def __repr__(self):
18269 
    L = ['%s=%r' % (key, value)
18270 
      for key, value in self.__dict__.iteritems()]
18271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18272 
 
18273 
  def __eq__(self, other):
18274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18275 
 
18276 
  def __ne__(self, other):
18277 
    return not (self == other)
18278 
 
18279 
class updateTimestampForAmazonFeeds_result:
18280 
  """
18281 
  Attributes:
18282 
   - success
18283 
  """
18284 
 
18285 
  thrift_spec = (
18286 
    (0, TType.BOOL, 'success', None, None, ), # 0
18287 
  )
18288 
 
18289 
  def __init__(self, success=None,):
18290 
    self.success = success
18291 
 
18292 
  def read(self, iprot):
18293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18295 
      return
18296 
    iprot.readStructBegin()
18297 
    while True:
18298 
      (fname, ftype, fid) = iprot.readFieldBegin()
18299 
      if ftype == TType.STOP:
18300 
        break
18301 
      if fid == 0:
18302 
        if ftype == TType.BOOL:
18303 
          self.success = iprot.readBool();
18304 
        else:
18305 
          iprot.skip(ftype)
18306 
      else:
18307 
        iprot.skip(ftype)
18308 
      iprot.readFieldEnd()
18309 
    iprot.readStructEnd()
18310 
 
18311 
  def write(self, oprot):
18312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18314 
      return
18315 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18316 
    if self.success is not None:
18317 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18318 
      oprot.writeBool(self.success)
18319 
      oprot.writeFieldEnd()
18320 
    oprot.writeFieldStop()
18321 
    oprot.writeStructEnd()
18322 
 
18323 
  def validate(self):
18324 
    return
18325 
 
18326 
 
18327 
  def __repr__(self):
18328 
    L = ['%s=%r' % (key, value)
18329 
      for key, value in self.__dict__.iteritems()]
18330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18331 
 
18332 
  def __eq__(self, other):
18333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18334 
 
18335 
  def __ne__(self, other):
18336 
    return not (self == other)
7897 amar.kumar 18337 
 
18338 
class getAllParentCategories_args:
18339 
 
18340 
  thrift_spec = (
18341 
  )
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      else:
18353 
        iprot.skip(ftype)
18354 
      iprot.readFieldEnd()
18355 
    iprot.readStructEnd()
18356 
 
18357 
  def write(self, oprot):
18358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18360 
      return
18361 
    oprot.writeStructBegin('getAllParentCategories_args')
18362 
    oprot.writeFieldStop()
18363 
    oprot.writeStructEnd()
18364 
 
18365 
  def validate(self):
18366 
    return
18367 
 
18368 
 
18369 
  def __repr__(self):
18370 
    L = ['%s=%r' % (key, value)
18371 
      for key, value in self.__dict__.iteritems()]
18372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18373 
 
18374 
  def __eq__(self, other):
18375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18376 
 
18377 
  def __ne__(self, other):
18378 
    return not (self == other)
18379 
 
18380 
class getAllParentCategories_result:
18381 
  """
18382 
  Attributes:
18383 
   - success
18384 
  """
18385 
 
18386 
  thrift_spec = (
18387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
18388 
  )
18389 
 
18390 
  def __init__(self, success=None,):
18391 
    self.success = success
18392 
 
18393 
  def read(self, iprot):
18394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18396 
      return
18397 
    iprot.readStructBegin()
18398 
    while True:
18399 
      (fname, ftype, fid) = iprot.readFieldBegin()
18400 
      if ftype == TType.STOP:
18401 
        break
18402 
      if fid == 0:
18403 
        if ftype == TType.LIST:
18404 
          self.success = []
18405 
          (_etype375, _size372) = iprot.readListBegin()
18406 
          for _i376 in xrange(_size372):
18407 
            _elem377 = Category()
18408 
            _elem377.read(iprot)
18409 
            self.success.append(_elem377)
18410 
          iprot.readListEnd()
18411 
        else:
18412 
          iprot.skip(ftype)
18413 
      else:
18414 
        iprot.skip(ftype)
18415 
      iprot.readFieldEnd()
18416 
    iprot.readStructEnd()
18417 
 
18418 
  def write(self, oprot):
18419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18421 
      return
18422 
    oprot.writeStructBegin('getAllParentCategories_result')
18423 
    if self.success is not None:
18424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18426 
      for iter378 in self.success:
18427 
        iter378.write(oprot)
18428 
      oprot.writeListEnd()
18429 
      oprot.writeFieldEnd()
18430 
    oprot.writeFieldStop()
18431 
    oprot.writeStructEnd()
18432 
 
18433 
  def validate(self):
18434 
    return
18435 
 
18436 
 
18437 
  def __repr__(self):
18438 
    L = ['%s=%r' % (key, value)
18439 
      for key, value in self.__dict__.iteritems()]
18440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18441 
 
18442 
  def __eq__(self, other):
18443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18444 
 
18445 
  def __ne__(self, other):
18446 
    return not (self == other)
7977 kshitij.so 18447 
 
18448 
class addPageViewEvent_args:
18449 
  """
18450 
  Attributes:
18451 
   - pageViewEvents
18452 
  """
18453 
 
18454 
  thrift_spec = (
18455 
    None, # 0
18456 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
18457 
  )
18458 
 
18459 
  def __init__(self, pageViewEvents=None,):
18460 
    self.pageViewEvents = pageViewEvents
18461 
 
18462 
  def read(self, iprot):
18463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18465 
      return
18466 
    iprot.readStructBegin()
18467 
    while True:
18468 
      (fname, ftype, fid) = iprot.readFieldBegin()
18469 
      if ftype == TType.STOP:
18470 
        break
18471 
      if fid == 1:
18472 
        if ftype == TType.STRUCT:
18473 
          self.pageViewEvents = PageViewEvents()
18474 
          self.pageViewEvents.read(iprot)
18475 
        else:
18476 
          iprot.skip(ftype)
18477 
      else:
18478 
        iprot.skip(ftype)
18479 
      iprot.readFieldEnd()
18480 
    iprot.readStructEnd()
18481 
 
18482 
  def write(self, oprot):
18483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18485 
      return
18486 
    oprot.writeStructBegin('addPageViewEvent_args')
18487 
    if self.pageViewEvents is not None:
18488 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
18489 
      self.pageViewEvents.write(oprot)
18490 
      oprot.writeFieldEnd()
18491 
    oprot.writeFieldStop()
18492 
    oprot.writeStructEnd()
18493 
 
18494 
  def validate(self):
18495 
    return
18496 
 
18497 
 
18498 
  def __repr__(self):
18499 
    L = ['%s=%r' % (key, value)
18500 
      for key, value in self.__dict__.iteritems()]
18501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18502 
 
18503 
  def __eq__(self, other):
18504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18505 
 
18506 
  def __ne__(self, other):
18507 
    return not (self == other)
18508 
 
18509 
class addPageViewEvent_result:
18510 
 
18511 
  thrift_spec = (
18512 
  )
18513 
 
18514 
  def read(self, iprot):
18515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18517 
      return
18518 
    iprot.readStructBegin()
18519 
    while True:
18520 
      (fname, ftype, fid) = iprot.readFieldBegin()
18521 
      if ftype == TType.STOP:
18522 
        break
18523 
      else:
18524 
        iprot.skip(ftype)
18525 
      iprot.readFieldEnd()
18526 
    iprot.readStructEnd()
18527 
 
18528 
  def write(self, oprot):
18529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18531 
      return
18532 
    oprot.writeStructBegin('addPageViewEvent_result')
18533 
    oprot.writeFieldStop()
18534 
    oprot.writeStructEnd()
18535 
 
18536 
  def validate(self):
18537 
    return
18538 
 
18539 
 
18540 
  def __repr__(self):
18541 
    L = ['%s=%r' % (key, value)
18542 
      for key, value in self.__dict__.iteritems()]
18543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18544 
 
18545 
  def __eq__(self, other):
18546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18547 
 
18548 
  def __ne__(self, other):
18549 
    return not (self == other)
18550 
 
18551 
class addCartEvent_args:
18552 
  """
18553 
  Attributes:
18554 
   - cartEvents
18555 
  """
18556 
 
18557 
  thrift_spec = (
18558 
    None, # 0
18559 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
18560 
  )
18561 
 
18562 
  def __init__(self, cartEvents=None,):
18563 
    self.cartEvents = cartEvents
18564 
 
18565 
  def read(self, iprot):
18566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18568 
      return
18569 
    iprot.readStructBegin()
18570 
    while True:
18571 
      (fname, ftype, fid) = iprot.readFieldBegin()
18572 
      if ftype == TType.STOP:
18573 
        break
18574 
      if fid == 1:
18575 
        if ftype == TType.STRUCT:
18576 
          self.cartEvents = CartEvents()
18577 
          self.cartEvents.read(iprot)
18578 
        else:
18579 
          iprot.skip(ftype)
18580 
      else:
18581 
        iprot.skip(ftype)
18582 
      iprot.readFieldEnd()
18583 
    iprot.readStructEnd()
18584 
 
18585 
  def write(self, oprot):
18586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18588 
      return
18589 
    oprot.writeStructBegin('addCartEvent_args')
18590 
    if self.cartEvents is not None:
18591 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
18592 
      self.cartEvents.write(oprot)
18593 
      oprot.writeFieldEnd()
18594 
    oprot.writeFieldStop()
18595 
    oprot.writeStructEnd()
18596 
 
18597 
  def validate(self):
18598 
    return
18599 
 
18600 
 
18601 
  def __repr__(self):
18602 
    L = ['%s=%r' % (key, value)
18603 
      for key, value in self.__dict__.iteritems()]
18604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18605 
 
18606 
  def __eq__(self, other):
18607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18608 
 
18609 
  def __ne__(self, other):
18610 
    return not (self == other)
18611 
 
18612 
class addCartEvent_result:
18613 
 
18614 
  thrift_spec = (
18615 
  )
18616 
 
18617 
  def read(self, iprot):
18618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18620 
      return
18621 
    iprot.readStructBegin()
18622 
    while True:
18623 
      (fname, ftype, fid) = iprot.readFieldBegin()
18624 
      if ftype == TType.STOP:
18625 
        break
18626 
      else:
18627 
        iprot.skip(ftype)
18628 
      iprot.readFieldEnd()
18629 
    iprot.readStructEnd()
18630 
 
18631 
  def write(self, oprot):
18632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18634 
      return
18635 
    oprot.writeStructBegin('addCartEvent_result')
18636 
    oprot.writeFieldStop()
18637 
    oprot.writeStructEnd()
18638 
 
18639 
  def validate(self):
18640 
    return
18641 
 
18642 
 
18643 
  def __repr__(self):
18644 
    L = ['%s=%r' % (key, value)
18645 
      for key, value in self.__dict__.iteritems()]
18646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18647 
 
18648 
  def __eq__(self, other):
18649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18650 
 
18651 
  def __ne__(self, other):
18652 
    return not (self == other)
8139 kshitij.so 18653 
 
18654 
class getAmazonListedItems_args:
18655 
  """
18656 
  Attributes:
18657 
   - offset
18658 
   - limit
18659 
  """
18660 
 
18661 
  thrift_spec = (
18662 
    None, # 0
18663 
    (1, TType.I64, 'offset', None, None, ), # 1
18664 
    (2, TType.I64, 'limit', None, None, ), # 2
18665 
  )
18666 
 
18667 
  def __init__(self, offset=None, limit=None,):
18668 
    self.offset = offset
18669 
    self.limit = limit
18670 
 
18671 
  def read(self, iprot):
18672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18674 
      return
18675 
    iprot.readStructBegin()
18676 
    while True:
18677 
      (fname, ftype, fid) = iprot.readFieldBegin()
18678 
      if ftype == TType.STOP:
18679 
        break
18680 
      if fid == 1:
18681 
        if ftype == TType.I64:
18682 
          self.offset = iprot.readI64();
18683 
        else:
18684 
          iprot.skip(ftype)
18685 
      elif fid == 2:
18686 
        if ftype == TType.I64:
18687 
          self.limit = iprot.readI64();
18688 
        else:
18689 
          iprot.skip(ftype)
18690 
      else:
18691 
        iprot.skip(ftype)
18692 
      iprot.readFieldEnd()
18693 
    iprot.readStructEnd()
18694 
 
18695 
  def write(self, oprot):
18696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18698 
      return
18699 
    oprot.writeStructBegin('getAmazonListedItems_args')
18700 
    if self.offset is not None:
18701 
      oprot.writeFieldBegin('offset', TType.I64, 1)
18702 
      oprot.writeI64(self.offset)
18703 
      oprot.writeFieldEnd()
18704 
    if self.limit is not None:
18705 
      oprot.writeFieldBegin('limit', TType.I64, 2)
18706 
      oprot.writeI64(self.limit)
18707 
      oprot.writeFieldEnd()
18708 
    oprot.writeFieldStop()
18709 
    oprot.writeStructEnd()
18710 
 
18711 
  def validate(self):
18712 
    return
18713 
 
18714 
 
18715 
  def __repr__(self):
18716 
    L = ['%s=%r' % (key, value)
18717 
      for key, value in self.__dict__.iteritems()]
18718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18719 
 
18720 
  def __eq__(self, other):
18721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18722 
 
18723 
  def __ne__(self, other):
18724 
    return not (self == other)
18725 
 
18726 
class getAmazonListedItems_result:
18727 
  """
18728 
  Attributes:
18729 
   - success
18730 
  """
18731 
 
18732 
  thrift_spec = (
18733 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18734 
  )
18735 
 
18736 
  def __init__(self, success=None,):
18737 
    self.success = success
18738 
 
18739 
  def read(self, iprot):
18740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18742 
      return
18743 
    iprot.readStructBegin()
18744 
    while True:
18745 
      (fname, ftype, fid) = iprot.readFieldBegin()
18746 
      if ftype == TType.STOP:
18747 
        break
18748 
      if fid == 0:
18749 
        if ftype == TType.LIST:
18750 
          self.success = []
18751 
          (_etype382, _size379) = iprot.readListBegin()
18752 
          for _i383 in xrange(_size379):
18753 
            _elem384 = Amazonlisted()
18754 
            _elem384.read(iprot)
18755 
            self.success.append(_elem384)
18756 
          iprot.readListEnd()
18757 
        else:
18758 
          iprot.skip(ftype)
18759 
      else:
18760 
        iprot.skip(ftype)
18761 
      iprot.readFieldEnd()
18762 
    iprot.readStructEnd()
18763 
 
18764 
  def write(self, oprot):
18765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18767 
      return
18768 
    oprot.writeStructBegin('getAmazonListedItems_result')
18769 
    if self.success is not None:
18770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18771 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18772 
      for iter385 in self.success:
18773 
        iter385.write(oprot)
18774 
      oprot.writeListEnd()
18775 
      oprot.writeFieldEnd()
18776 
    oprot.writeFieldStop()
18777 
    oprot.writeStructEnd()
18778 
 
18779 
  def validate(self):
18780 
    return
18781 
 
18782 
 
18783 
  def __repr__(self):
18784 
    L = ['%s=%r' % (key, value)
18785 
      for key, value in self.__dict__.iteritems()]
18786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18787 
 
18788 
  def __eq__(self, other):
18789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18790 
 
18791 
  def __ne__(self, other):
18792 
    return not (self == other)
8168 kshitij.so 18793 
 
18794 
class updateAmazonAttributesInBulk_args:
18795 
  """
18796 
  Attributes:
18797 
   - amazonlisted
18798 
  """
18799 
 
18800 
  thrift_spec = (
18801 
    None, # 0
18802 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
18803 
  )
18804 
 
18805 
  def __init__(self, amazonlisted=None,):
18806 
    self.amazonlisted = amazonlisted
18807 
 
18808 
  def read(self, iprot):
18809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18811 
      return
18812 
    iprot.readStructBegin()
18813 
    while True:
18814 
      (fname, ftype, fid) = iprot.readFieldBegin()
18815 
      if ftype == TType.STOP:
18816 
        break
18817 
      if fid == 1:
18818 
        if ftype == TType.MAP:
18819 
          self.amazonlisted = {}
18820 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
18821 
          for _i390 in xrange(_size386):
18822 
            _key391 = iprot.readI64();
18823 
            _val392 = Amazonlisted()
18824 
            _val392.read(iprot)
18825 
            self.amazonlisted[_key391] = _val392
18826 
          iprot.readMapEnd()
18827 
        else:
18828 
          iprot.skip(ftype)
18829 
      else:
18830 
        iprot.skip(ftype)
18831 
      iprot.readFieldEnd()
18832 
    iprot.readStructEnd()
18833 
 
18834 
  def write(self, oprot):
18835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18837 
      return
18838 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
18839 
    if self.amazonlisted is not None:
18840 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
18841 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
18842 
      for kiter393,viter394 in self.amazonlisted.items():
18843 
        oprot.writeI64(kiter393)
18844 
        viter394.write(oprot)
18845 
      oprot.writeMapEnd()
18846 
      oprot.writeFieldEnd()
18847 
    oprot.writeFieldStop()
18848 
    oprot.writeStructEnd()
18849 
 
18850 
  def validate(self):
18851 
    return
18852 
 
18853 
 
18854 
  def __repr__(self):
18855 
    L = ['%s=%r' % (key, value)
18856 
      for key, value in self.__dict__.iteritems()]
18857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18858 
 
18859 
  def __eq__(self, other):
18860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18861 
 
18862 
  def __ne__(self, other):
18863 
    return not (self == other)
18864 
 
18865 
class updateAmazonAttributesInBulk_result:
18866 
  """
18867 
  Attributes:
18868 
   - success
18869 
  """
18870 
 
18871 
  thrift_spec = (
18872 
    (0, TType.BOOL, 'success', None, None, ), # 0
18873 
  )
18874 
 
18875 
  def __init__(self, success=None,):
18876 
    self.success = success
18877 
 
18878 
  def read(self, iprot):
18879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18881 
      return
18882 
    iprot.readStructBegin()
18883 
    while True:
18884 
      (fname, ftype, fid) = iprot.readFieldBegin()
18885 
      if ftype == TType.STOP:
18886 
        break
18887 
      if fid == 0:
18888 
        if ftype == TType.BOOL:
18889 
          self.success = iprot.readBool();
18890 
        else:
18891 
          iprot.skip(ftype)
18892 
      else:
18893 
        iprot.skip(ftype)
18894 
      iprot.readFieldEnd()
18895 
    iprot.readStructEnd()
18896 
 
18897 
  def write(self, oprot):
18898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18900 
      return
18901 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
18902 
    if self.success is not None:
18903 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18904 
      oprot.writeBool(self.success)
18905 
      oprot.writeFieldEnd()
18906 
    oprot.writeFieldStop()
18907 
    oprot.writeStructEnd()
18908 
 
18909 
  def validate(self):
18910 
    return
18911 
 
18912 
 
18913 
  def __repr__(self):
18914 
    L = ['%s=%r' % (key, value)
18915 
      for key, value in self.__dict__.iteritems()]
18916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18917 
 
18918 
  def __eq__(self, other):
18919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18920 
 
18921 
  def __ne__(self, other):
18922 
    return not (self == other)