Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
6850 kshitij.so 316 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
317 
    """
318 
    Parameters:
319 
     - bannerName
320 
     - imageName
321 
     - link
322 
     - priority
323 
     - isActive
324 
     - hasMap
325 
    """
326 
    pass
327 
 
328 
  def getAllBanners(self, ):
329 
    pass
330 
 
331 
  def deleteBanner(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getBannerDetails(self, bannerName):
339 
    """
340 
    Parameters:
341 
     - bannerName
342 
    """
343 
    pass
344 
 
345 
  def getActiveBanners(self, ):
346 
    pass
347 
 
6849 kshitij.so 348 
  def addBannerMap(self, bannerName, mapLink, coordinates):
349 
    """
350 
    Parameters:
351 
     - bannerName
352 
     - mapLink
353 
     - coordinates
354 
    """
355 
    pass
356 
 
357 
  def deleteBannerMap(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
364 
  def getBannerMapDetails(self, bannerName):
365 
    """
366 
    Parameters:
367 
     - bannerName
368 
    """
369 
    pass
370 
 
5944 mandeep.dh 371 
  def deleteSimilarItem(self, itemId, catalogItemId):
372 
    """
373 
    Delete similar item.
374 
 
375 
    Parameters:
376 
     - itemId
377 
     - catalogItemId
378 
    """
379 
    pass
380 
 
381 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
382 
    """
383 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
384 
    If yes, returns the itemId else returns 0
385 
 
386 
    Parameters:
387 
     - brand
388 
     - modelNumber
389 
     - modelName
390 
     - color
391 
    """
392 
    pass
393 
 
394 
  def validateRiskyStatus(self, itemId):
395 
    """
396 
    Check wether item is risky and change status if inventory is not available for risky items
397 
 
398 
    Parameters:
399 
     - itemId
400 
    """
401 
    pass
402 
 
403 
  def changeItemRiskyFlag(self, itemId, risky):
404 
    """
405 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
406 
 
407 
    Parameters:
408 
     - itemId
409 
     - risky
410 
    """
411 
    pass
412 
 
413 
  def getItemsByRiskyFlag(self, ):
414 
    """
415 
    Returns list of items marked as risky.
416 
    """
417 
    pass
418 
 
419 
  def getItemsForMasterSheet(self, category, brand):
420 
    """
421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
422 
 
423 
    Parameters:
424 
     - category
425 
     - brand
426 
    """
427 
    pass
428 
 
429 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
430 
    """
431 
    Returns list of catalog ids of items with same similarity index as of the given itemId
432 
 
433 
    Parameters:
434 
     - beginIndex
435 
     - totalItems
436 
     - itemId
437 
    """
438 
    pass
439 
 
440 
  def addProductNotification(self, itemId, email):
441 
    """
442 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
443 
 
444 
    Parameters:
445 
     - itemId
446 
     - email
447 
    """
448 
    pass
449 
 
450 
  def sendProductNotifications(self, ):
451 
    """
452 
    Send the product notifications to the users for items which has stock.
453 
    """
454 
    pass
455 
 
456 
  def getAllBrandsByCategory(self, categoryId):
457 
    """
458 
    Returns list of brand names for a given category Id
459 
 
460 
    Parameters:
461 
     - categoryId
462 
    """
463 
    pass
464 
 
465 
  def getAllBrands(self, ):
466 
    """
467 
    Returns list of brand names
468 
    """
469 
    pass
470 
 
471 
  def getAllSources(self, ):
472 
    """
473 
    Return list of all sources
474 
    """
475 
    pass
476 
 
477 
  def getItemPricingBySource(self, itemId, sourceId):
478 
    """
479 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
480 
 
481 
    Parameters:
482 
     - itemId
483 
     - sourceId
484 
    """
485 
    pass
486 
 
487 
  def addSourceItemPricing(self, sourceItemPricing):
488 
    """
489 
    Adds prices to be displayed corresponding to the item if user comes from a source.
490 
    If item is not found or source is not found, it will throw exception.
491 
 
492 
    Parameters:
493 
     - sourceItemPricing
494 
    """
495 
    pass
496 
 
497 
  def getAllSourcePricing(self, itemId):
498 
    """
499 
    Returns the list of source pricing information of an item.
500 
    Raises an exception if item not found corresponding to itemId
501 
 
502 
    Parameters:
503 
     - itemId
504 
    """
505 
    pass
506 
 
507 
  def getItemForSource(self, item_id, sourceId):
508 
    """
509 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
510 
 
511 
    Parameters:
512 
     - item_id
513 
     - sourceId
514 
    """
515 
    pass
516 
 
517 
  def searchItemsInRange(self, searchTerms, offset, limit):
518 
    """
519 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
520 
 
521 
    Parameters:
522 
     - searchTerms
523 
     - offset
524 
     - limit
525 
    """
526 
    pass
527 
 
528 
  def getSearchResultCount(self, searchTerms):
529 
    """
530 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
531 
 
532 
    Parameters:
533 
     - searchTerms
534 
    """
535 
    pass
536 
 
537 
  def getProductNotifications(self, startDateTime):
538 
    """
539 
    Returns a list of product notifications added after a supplied datetime
540 
 
541 
    Parameters:
542 
     - startDateTime
543 
    """
544 
    pass
545 
 
7897 amar.kumar 546 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 547 
    """
548 
    Returns a list of count of requests for product notification against each item
549 
 
550 
    Parameters:
551 
     - startDateTime
7897 amar.kumar 552 
     - categoryId
5944 mandeep.dh 553 
    """
554 
    pass
555 
 
556 
  def addAuthorizationLog(self, itemId, username, reason):
557 
    """
558 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
559 
 
560 
    Parameters:
561 
     - itemId
562 
     - username
563 
     - reason
564 
    """
565 
    pass
566 
 
567 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
568 
    """
569 
    Parameters:
570 
     - catalog_item_id
571 
     - voucherType
572 
     - voucherAmount
573 
    """
574 
    pass
575 
 
576 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
577 
    """
578 
    Parameters:
579 
     - catalog_item_id
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getVoucherAmount(self, itemId, voucherType):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
     - voucherType
589 
    """
590 
    pass
591 
 
592 
  def getAllItemVouchers(self, itemId):
593 
    """
594 
    Parameters:
595 
     - itemId
596 
    """
597 
    pass
598 
 
599 
  def isValidCatalogItemId(self, catalog_item_id):
600 
    """
601 
    Parameters:
602 
     - catalog_item_id
603 
    """
604 
    pass
605 
 
7330 amit.gupta 606 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 607 
    """
608 
    Parameters:
609 
     - itemId
7330 amit.gupta 610 
     - stateId
6039 amit.gupta 611 
     - price
612 
    """
613 
    pass
5944 mandeep.dh 614 
 
6039 amit.gupta 615 
  def getVatAmountForItem(self, itemId, price):
616 
    """
617 
    Parameters:
618 
     - itemId
619 
     - price
620 
    """
621 
    pass
622 
 
6531 vikram.rag 623 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
624 
    """
625 
    Parameters:
626 
     - offset
627 
     - limit
628 
    """
629 
    pass
6039 amit.gupta 630 
 
6821 amar.kumar 631 
  def getAllAliveItems(self, ):
632 
    pass
633 
 
6921 anupam.sin 634 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 635 
    """
636 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 637 
 
6805 anupam.sin 638 
    Parameters:
639 
     - itemId
6921 anupam.sin 640 
     - price
6805 anupam.sin 641 
     - insurerId
642 
     - quantity
643 
    """
644 
    pass
645 
 
646 
  def getInsurer(self, insurerId):
647 
    """
648 
    Parameters:
649 
     - insurerId
650 
    """
651 
    pass
652 
 
6838 vikram.rag 653 
  def getAllInsurers(self, ):
654 
    pass
6805 anupam.sin 655 
 
6962 rajveer 656 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
657 
    """
658 
    Parameters:
659 
     - insurerId
660 
     - amount
661 
    """
662 
    pass
6838 vikram.rag 663 
 
7190 amar.kumar 664 
  def getFreebieForItem(self, itemId):
665 
    """
666 
    Parameters:
667 
     - itemId
668 
    """
669 
    pass
6962 rajveer 670 
 
7190 amar.kumar 671 
  def addOrUpdateFreebieForItem(self, freebieItem):
672 
    """
673 
    Parameters:
674 
     - freebieItem
675 
    """
676 
    pass
677 
 
7272 amit.gupta 678 
  def addOrUpdateBrandInfo(self, brandInfo):
679 
    """
680 
    Parameters:
681 
     - brandInfo
682 
    """
683 
    pass
684 
 
685 
  def getBrandInfo(self, ):
686 
    pass
687 
 
7256 rajveer 688 
  def getStorePricing(self, itemId):
689 
    """
690 
    Parameters:
691 
     - itemId
692 
    """
693 
    pass
7190 amar.kumar 694 
 
7306 rajveer 695 
  def getStorePricings(self, itemIds):
696 
    """
697 
    Parameters:
698 
     - itemIds
699 
    """
700 
    pass
701 
 
7382 rajveer 702 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 703 
    """
704 
    Parameters:
705 
     - sp
7382 rajveer 706 
     - allColors
7265 rajveer 707 
    """
708 
    pass
7256 rajveer 709 
 
7281 kshitij.so 710 
  def getAllAmazonListedItems(self, ):
711 
    pass
7265 rajveer 712 
 
7281 kshitij.so 713 
  def getAmazonItemDetails(self, itemId):
714 
    """
715 
    Parameters:
716 
     - itemId
717 
    """
718 
    pass
719 
 
7367 kshitij.so 720 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 721 
    """
722 
    Parameters:
723 
     - itemId
724 
     - fbaPrice
725 
     - sellingPrice
726 
     - isFba
727 
     - isNonFba
728 
     - isInventoryOverride
7367 kshitij.so 729 
     - handlingTime
730 
     - isCustomTime
7281 kshitij.so 731 
    """
732 
    pass
733 
 
734 
  def addAmazonItem(self, amazonlisted):
735 
    """
736 
    Parameters:
737 
     - amazonlisted
738 
    """
739 
    pass
740 
 
7291 vikram.rag 741 
  def getAsinItems(self, ):
742 
    pass
7281 kshitij.so 743 
 
7291 vikram.rag 744 
  def getAllFbaListedItems(self, ):
745 
    pass
746 
 
747 
  def getAllNonFbaListedItems(self, ):
748 
    pass
749 
 
7460 kshitij.so 750 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
751 
    """
752 
    Parameters:
753 
     - itemId
754 
     - holdInventory
755 
     - defaultInventory
756 
    """
757 
    pass
7291 vikram.rag 758 
 
7770 kshitij.so 759 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
760 
    """
761 
    Parameters:
762 
     - type
763 
     - sku
764 
     - timestamp
765 
    """
766 
    pass
7460 kshitij.so 767 
 
7897 amar.kumar 768 
  def getAllParentCategories(self, ):
769 
    pass
7770 kshitij.so 770 
 
7897 amar.kumar 771 
 
5944 mandeep.dh 772 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
773 
  def __init__(self, iprot, oprot=None):
774 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
775 
 
776 
  def addItem(self, item):
777 
    """
778 
    Availability and inventory attributes
779 
 
780 
    Parameters:
781 
     - item
782 
    """
783 
    self.send_addItem(item)
784 
    return self.recv_addItem()
785 
 
786 
  def send_addItem(self, item):
787 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
788 
    args = addItem_args()
789 
    args.item = item
790 
    args.write(self._oprot)
791 
    self._oprot.writeMessageEnd()
792 
    self._oprot.trans.flush()
793 
 
794 
  def recv_addItem(self, ):
795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
796 
    if mtype == TMessageType.EXCEPTION:
797 
      x = TApplicationException()
798 
      x.read(self._iprot)
799 
      self._iprot.readMessageEnd()
800 
      raise x
801 
    result = addItem_result()
802 
    result.read(self._iprot)
803 
    self._iprot.readMessageEnd()
804 
    if result.success is not None:
805 
      return result.success
806 
    if result.cex is not None:
807 
      raise result.cex
808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
809 
 
810 
  def updateItem(self, item):
811 
    """
812 
    Parameters:
813 
     - item
814 
    """
815 
    self.send_updateItem(item)
816 
    return self.recv_updateItem()
817 
 
818 
  def send_updateItem(self, item):
819 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
820 
    args = updateItem_args()
821 
    args.item = item
822 
    args.write(self._oprot)
823 
    self._oprot.writeMessageEnd()
824 
    self._oprot.trans.flush()
825 
 
826 
  def recv_updateItem(self, ):
827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
828 
    if mtype == TMessageType.EXCEPTION:
829 
      x = TApplicationException()
830 
      x.read(self._iprot)
831 
      self._iprot.readMessageEnd()
832 
      raise x
833 
    result = updateItem_result()
834 
    result.read(self._iprot)
835 
    self._iprot.readMessageEnd()
836 
    if result.success is not None:
837 
      return result.success
838 
    if result.cex is not None:
839 
      raise result.cex
840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
841 
 
842 
  def isActive(self, itemId):
843 
    """
844 
    Checks if the item given to the corresponding itemId is active. If it's active,
845 
    whether it's risky and if it's risky, its inventory position.
846 
 
847 
    Parameters:
848 
     - itemId
849 
    """
850 
    self.send_isActive(itemId)
851 
    return self.recv_isActive()
852 
 
853 
  def send_isActive(self, itemId):
854 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
855 
    args = isActive_args()
856 
    args.itemId = itemId
857 
    args.write(self._oprot)
858 
    self._oprot.writeMessageEnd()
859 
    self._oprot.trans.flush()
860 
 
861 
  def recv_isActive(self, ):
862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
863 
    if mtype == TMessageType.EXCEPTION:
864 
      x = TApplicationException()
865 
      x.read(self._iprot)
866 
      self._iprot.readMessageEnd()
867 
      raise x
868 
    result = isActive_result()
869 
    result.read(self._iprot)
870 
    self._iprot.readMessageEnd()
871 
    if result.success is not None:
872 
      return result.success
873 
    if result.isex is not None:
874 
      raise result.isex
875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
876 
 
7438 amit.gupta 877 
  def getItemsStatus(self, itemIds):
878 
    """
879 
    Parameters:
880 
     - itemIds
881 
    """
882 
    self.send_getItemsStatus(itemIds)
883 
    return self.recv_getItemsStatus()
884 
 
885 
  def send_getItemsStatus(self, itemIds):
886 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
887 
    args = getItemsStatus_args()
888 
    args.itemIds = itemIds
889 
    args.write(self._oprot)
890 
    self._oprot.writeMessageEnd()
891 
    self._oprot.trans.flush()
892 
 
893 
  def recv_getItemsStatus(self, ):
894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
895 
    if mtype == TMessageType.EXCEPTION:
896 
      x = TApplicationException()
897 
      x.read(self._iprot)
898 
      self._iprot.readMessageEnd()
899 
      raise x
900 
    result = getItemsStatus_result()
901 
    result.read(self._iprot)
902 
    self._iprot.readMessageEnd()
903 
    if result.success is not None:
904 
      return result.success
905 
    if result.isex is not None:
906 
      raise result.isex
907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
908 
 
5944 mandeep.dh 909 
  def getItemStatusDescription(self, itemId):
910 
    """
911 
    Parameters:
912 
     - itemId
913 
    """
914 
    self.send_getItemStatusDescription(itemId)
915 
    return self.recv_getItemStatusDescription()
916 
 
917 
  def send_getItemStatusDescription(self, itemId):
918 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
919 
    args = getItemStatusDescription_args()
920 
    args.itemId = itemId
921 
    args.write(self._oprot)
922 
    self._oprot.writeMessageEnd()
923 
    self._oprot.trans.flush()
924 
 
925 
  def recv_getItemStatusDescription(self, ):
926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
927 
    if mtype == TMessageType.EXCEPTION:
928 
      x = TApplicationException()
929 
      x.read(self._iprot)
930 
      self._iprot.readMessageEnd()
931 
      raise x
932 
    result = getItemStatusDescription_result()
933 
    result.read(self._iprot)
934 
    self._iprot.readMessageEnd()
935 
    if result.success is not None:
936 
      return result.success
937 
    if result.isex is not None:
938 
      raise result.isex
939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
940 
 
941 
  def startItemOn(self, item_id, timestamp):
942 
    """
943 
    Parameters:
944 
     - item_id
945 
     - timestamp
946 
    """
947 
    self.send_startItemOn(item_id, timestamp)
948 
    self.recv_startItemOn()
949 
 
950 
  def send_startItemOn(self, item_id, timestamp):
951 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
952 
    args = startItemOn_args()
953 
    args.item_id = item_id
954 
    args.timestamp = timestamp
955 
    args.write(self._oprot)
956 
    self._oprot.writeMessageEnd()
957 
    self._oprot.trans.flush()
958 
 
959 
  def recv_startItemOn(self, ):
960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
961 
    if mtype == TMessageType.EXCEPTION:
962 
      x = TApplicationException()
963 
      x.read(self._iprot)
964 
      self._iprot.readMessageEnd()
965 
      raise x
966 
    result = startItemOn_result()
967 
    result.read(self._iprot)
968 
    self._iprot.readMessageEnd()
969 
    if result.cex is not None:
970 
      raise result.cex
971 
    return
972 
 
973 
  def retireItemOn(self, item_id, timestamp):
974 
    """
975 
    Parameters:
976 
     - item_id
977 
     - timestamp
978 
    """
979 
    self.send_retireItemOn(item_id, timestamp)
980 
    self.recv_retireItemOn()
981 
 
982 
  def send_retireItemOn(self, item_id, timestamp):
983 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
984 
    args = retireItemOn_args()
985 
    args.item_id = item_id
986 
    args.timestamp = timestamp
987 
    args.write(self._oprot)
988 
    self._oprot.writeMessageEnd()
989 
    self._oprot.trans.flush()
990 
 
991 
  def recv_retireItemOn(self, ):
992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
993 
    if mtype == TMessageType.EXCEPTION:
994 
      x = TApplicationException()
995 
      x.read(self._iprot)
996 
      self._iprot.readMessageEnd()
997 
      raise x
998 
    result = retireItemOn_result()
999 
    result.read(self._iprot)
1000 
    self._iprot.readMessageEnd()
1001 
    if result.cex is not None:
1002 
      raise result.cex
1003 
    return
1004 
 
1005 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1006 
    """
1007 
    Parameters:
1008 
     - item_id
1009 
     - timestamp
1010 
     - newstatus
1011 
    """
1012 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1013 
    self.recv_changeItemStatus()
1014 
 
1015 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1016 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1017 
    args = changeItemStatus_args()
1018 
    args.item_id = item_id
1019 
    args.timestamp = timestamp
1020 
    args.newstatus = newstatus
1021 
    args.write(self._oprot)
1022 
    self._oprot.writeMessageEnd()
1023 
    self._oprot.trans.flush()
1024 
 
1025 
  def recv_changeItemStatus(self, ):
1026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1027 
    if mtype == TMessageType.EXCEPTION:
1028 
      x = TApplicationException()
1029 
      x.read(self._iprot)
1030 
      self._iprot.readMessageEnd()
1031 
      raise x
1032 
    result = changeItemStatus_result()
1033 
    result.read(self._iprot)
1034 
    self._iprot.readMessageEnd()
1035 
    if result.cex is not None:
1036 
      raise result.cex
1037 
    return
1038 
 
1039 
  def getItem(self, item_id):
1040 
    """
1041 
    Parameters:
1042 
     - item_id
1043 
    """
1044 
    self.send_getItem(item_id)
1045 
    return self.recv_getItem()
1046 
 
1047 
  def send_getItem(self, item_id):
1048 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1049 
    args = getItem_args()
1050 
    args.item_id = item_id
1051 
    args.write(self._oprot)
1052 
    self._oprot.writeMessageEnd()
1053 
    self._oprot.trans.flush()
1054 
 
1055 
  def recv_getItem(self, ):
1056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1057 
    if mtype == TMessageType.EXCEPTION:
1058 
      x = TApplicationException()
1059 
      x.read(self._iprot)
1060 
      self._iprot.readMessageEnd()
1061 
      raise x
1062 
    result = getItem_result()
1063 
    result.read(self._iprot)
1064 
    self._iprot.readMessageEnd()
1065 
    if result.success is not None:
1066 
      return result.success
1067 
    if result.cex is not None:
1068 
      raise result.cex
1069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1070 
 
1071 
  def getItemsByCatalogId(self, catalog_item_id):
1072 
    """
1073 
    Parameters:
1074 
     - catalog_item_id
1075 
    """
1076 
    self.send_getItemsByCatalogId(catalog_item_id)
1077 
    return self.recv_getItemsByCatalogId()
1078 
 
1079 
  def send_getItemsByCatalogId(self, catalog_item_id):
1080 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1081 
    args = getItemsByCatalogId_args()
1082 
    args.catalog_item_id = catalog_item_id
1083 
    args.write(self._oprot)
1084 
    self._oprot.writeMessageEnd()
1085 
    self._oprot.trans.flush()
1086 
 
1087 
  def recv_getItemsByCatalogId(self, ):
1088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1089 
    if mtype == TMessageType.EXCEPTION:
1090 
      x = TApplicationException()
1091 
      x.read(self._iprot)
1092 
      self._iprot.readMessageEnd()
1093 
      raise x
1094 
    result = getItemsByCatalogId_result()
1095 
    result.read(self._iprot)
1096 
    self._iprot.readMessageEnd()
1097 
    if result.success is not None:
1098 
      return result.success
1099 
    if result.cex is not None:
1100 
      raise result.cex
1101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1102 
 
1103 
  def getValidItemsByCatalogId(self, catalog_item_id):
1104 
    """
1105 
    Parameters:
1106 
     - catalog_item_id
1107 
    """
1108 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1109 
    return self.recv_getValidItemsByCatalogId()
1110 
 
1111 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1112 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1113 
    args = getValidItemsByCatalogId_args()
1114 
    args.catalog_item_id = catalog_item_id
1115 
    args.write(self._oprot)
1116 
    self._oprot.writeMessageEnd()
1117 
    self._oprot.trans.flush()
1118 
 
1119 
  def recv_getValidItemsByCatalogId(self, ):
1120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1121 
    if mtype == TMessageType.EXCEPTION:
1122 
      x = TApplicationException()
1123 
      x.read(self._iprot)
1124 
      self._iprot.readMessageEnd()
1125 
      raise x
1126 
    result = getValidItemsByCatalogId_result()
1127 
    result.read(self._iprot)
1128 
    self._iprot.readMessageEnd()
1129 
    if result.success is not None:
1130 
      return result.success
1131 
    if result.cex is not None:
1132 
      raise result.cex
1133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1134 
 
1135 
  def getAllItems(self, isActive):
1136 
    """
1137 
    Parameters:
1138 
     - isActive
1139 
    """
1140 
    self.send_getAllItems(isActive)
1141 
    return self.recv_getAllItems()
1142 
 
1143 
  def send_getAllItems(self, isActive):
1144 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1145 
    args = getAllItems_args()
1146 
    args.isActive = isActive
1147 
    args.write(self._oprot)
1148 
    self._oprot.writeMessageEnd()
1149 
    self._oprot.trans.flush()
1150 
 
1151 
  def recv_getAllItems(self, ):
1152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1153 
    if mtype == TMessageType.EXCEPTION:
1154 
      x = TApplicationException()
1155 
      x.read(self._iprot)
1156 
      self._iprot.readMessageEnd()
1157 
      raise x
1158 
    result = getAllItems_result()
1159 
    result.read(self._iprot)
1160 
    self._iprot.readMessageEnd()
1161 
    if result.success is not None:
1162 
      return result.success
1163 
    if result.cex is not None:
1164 
      raise result.cex
1165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1166 
 
1167 
  def getAllItemsByStatus(self, itemStatus):
1168 
    """
1169 
    Parameters:
1170 
     - itemStatus
1171 
    """
1172 
    self.send_getAllItemsByStatus(itemStatus)
1173 
    return self.recv_getAllItemsByStatus()
1174 
 
1175 
  def send_getAllItemsByStatus(self, itemStatus):
1176 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1177 
    args = getAllItemsByStatus_args()
1178 
    args.itemStatus = itemStatus
1179 
    args.write(self._oprot)
1180 
    self._oprot.writeMessageEnd()
1181 
    self._oprot.trans.flush()
1182 
 
1183 
  def recv_getAllItemsByStatus(self, ):
1184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1185 
    if mtype == TMessageType.EXCEPTION:
1186 
      x = TApplicationException()
1187 
      x.read(self._iprot)
1188 
      self._iprot.readMessageEnd()
1189 
      raise x
1190 
    result = getAllItemsByStatus_result()
1191 
    result.read(self._iprot)
1192 
    self._iprot.readMessageEnd()
1193 
    if result.success is not None:
1194 
      return result.success
1195 
    if result.cex is not None:
1196 
      raise result.cex
1197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1198 
 
1199 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1200 
    """
1201 
    Parameters:
1202 
     - entityId
1203 
     - category
1204 
     - brand
1205 
     - modelName
1206 
     - modelNumber
1207 
    """
1208 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1209 
    return self.recv_markItemAsContentComplete()
1210 
 
1211 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1212 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1213 
    args = markItemAsContentComplete_args()
1214 
    args.entityId = entityId
1215 
    args.category = category
1216 
    args.brand = brand
1217 
    args.modelName = modelName
1218 
    args.modelNumber = modelNumber
1219 
    args.write(self._oprot)
1220 
    self._oprot.writeMessageEnd()
1221 
    self._oprot.trans.flush()
1222 
 
1223 
  def recv_markItemAsContentComplete(self, ):
1224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1225 
    if mtype == TMessageType.EXCEPTION:
1226 
      x = TApplicationException()
1227 
      x.read(self._iprot)
1228 
      self._iprot.readMessageEnd()
1229 
      raise x
1230 
    result = markItemAsContentComplete_result()
1231 
    result.read(self._iprot)
1232 
    self._iprot.readMessageEnd()
1233 
    if result.success is not None:
1234 
      return result.success
1235 
    if result.cex is not None:
1236 
      raise result.cex
1237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1238 
 
1239 
  def getAllItemsInRange(self, offset, limit):
1240 
    """
1241 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1242 
 
1243 
    Parameters:
1244 
     - offset
1245 
     - limit
1246 
    """
1247 
    self.send_getAllItemsInRange(offset, limit)
1248 
    return self.recv_getAllItemsInRange()
1249 
 
1250 
  def send_getAllItemsInRange(self, offset, limit):
1251 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1252 
    args = getAllItemsInRange_args()
1253 
    args.offset = offset
1254 
    args.limit = limit
1255 
    args.write(self._oprot)
1256 
    self._oprot.writeMessageEnd()
1257 
    self._oprot.trans.flush()
1258 
 
1259 
  def recv_getAllItemsInRange(self, ):
1260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1261 
    if mtype == TMessageType.EXCEPTION:
1262 
      x = TApplicationException()
1263 
      x.read(self._iprot)
1264 
      self._iprot.readMessageEnd()
1265 
      raise x
1266 
    result = getAllItemsInRange_result()
1267 
    result.read(self._iprot)
1268 
    self._iprot.readMessageEnd()
1269 
    if result.success is not None:
1270 
      return result.success
1271 
    if result.cex is not None:
1272 
      raise result.cex
1273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1274 
 
1275 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1276 
    """
1277 
    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.
1278 
 
1279 
    Parameters:
1280 
     - itemStatus
1281 
     - offset
1282 
     - limit
1283 
    """
1284 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1285 
    return self.recv_getAllItemsByStatusInRange()
1286 
 
1287 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1288 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1289 
    args = getAllItemsByStatusInRange_args()
1290 
    args.itemStatus = itemStatus
1291 
    args.offset = offset
1292 
    args.limit = limit
1293 
    args.write(self._oprot)
1294 
    self._oprot.writeMessageEnd()
1295 
    self._oprot.trans.flush()
1296 
 
1297 
  def recv_getAllItemsByStatusInRange(self, ):
1298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1299 
    if mtype == TMessageType.EXCEPTION:
1300 
      x = TApplicationException()
1301 
      x.read(self._iprot)
1302 
      self._iprot.readMessageEnd()
1303 
      raise x
1304 
    result = getAllItemsByStatusInRange_result()
1305 
    result.read(self._iprot)
1306 
    self._iprot.readMessageEnd()
1307 
    if result.success is not None:
1308 
      return result.success
1309 
    if result.cex is not None:
1310 
      raise result.cex
1311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1312 
 
1313 
  def getItemCountByStatus(self, useStatus, itemStatus):
1314 
    """
1315 
    Gets a count of all items by status
1316 
 
1317 
    Parameters:
1318 
     - useStatus
1319 
     - itemStatus
1320 
    """
1321 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1322 
    return self.recv_getItemCountByStatus()
1323 
 
1324 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1325 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1326 
    args = getItemCountByStatus_args()
1327 
    args.useStatus = useStatus
1328 
    args.itemStatus = itemStatus
1329 
    args.write(self._oprot)
1330 
    self._oprot.writeMessageEnd()
1331 
    self._oprot.trans.flush()
1332 
 
1333 
  def recv_getItemCountByStatus(self, ):
1334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1335 
    if mtype == TMessageType.EXCEPTION:
1336 
      x = TApplicationException()
1337 
      x.read(self._iprot)
1338 
      self._iprot.readMessageEnd()
1339 
      raise x
1340 
    result = getItemCountByStatus_result()
1341 
    result.read(self._iprot)
1342 
    self._iprot.readMessageEnd()
1343 
    if result.success is not None:
1344 
      return result.success
1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1346 
 
1347 
  def getBestSellers(self, ):
1348 
    self.send_getBestSellers()
1349 
    return self.recv_getBestSellers()
1350 
 
1351 
  def send_getBestSellers(self, ):
1352 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1353 
    args = getBestSellers_args()
1354 
    args.write(self._oprot)
1355 
    self._oprot.writeMessageEnd()
1356 
    self._oprot.trans.flush()
1357 
 
1358 
  def recv_getBestSellers(self, ):
1359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1360 
    if mtype == TMessageType.EXCEPTION:
1361 
      x = TApplicationException()
1362 
      x.read(self._iprot)
1363 
      self._iprot.readMessageEnd()
1364 
      raise x
1365 
    result = getBestSellers_result()
1366 
    result.read(self._iprot)
1367 
    self._iprot.readMessageEnd()
1368 
    if result.success is not None:
1369 
      return result.success
1370 
    if result.isex is not None:
1371 
      raise result.isex
1372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1373 
 
1374 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1375 
    """
1376 
    Parameters:
1377 
     - beginIndex
1378 
     - totalItems
1379 
     - brand
1380 
     - category
1381 
    """
1382 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1383 
    return self.recv_getBestSellersCatalogIds()
1384 
 
1385 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1386 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1387 
    args = getBestSellersCatalogIds_args()
1388 
    args.beginIndex = beginIndex
1389 
    args.totalItems = totalItems
1390 
    args.brand = brand
1391 
    args.category = category
1392 
    args.write(self._oprot)
1393 
    self._oprot.writeMessageEnd()
1394 
    self._oprot.trans.flush()
1395 
 
1396 
  def recv_getBestSellersCatalogIds(self, ):
1397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1398 
    if mtype == TMessageType.EXCEPTION:
1399 
      x = TApplicationException()
1400 
      x.read(self._iprot)
1401 
      self._iprot.readMessageEnd()
1402 
      raise x
1403 
    result = getBestSellersCatalogIds_result()
1404 
    result.read(self._iprot)
1405 
    self._iprot.readMessageEnd()
1406 
    if result.success is not None:
1407 
      return result.success
1408 
    if result.cex is not None:
1409 
      raise result.cex
1410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1411 
 
1412 
  def getBestSellersCount(self, ):
1413 
    self.send_getBestSellersCount()
1414 
    return self.recv_getBestSellersCount()
1415 
 
1416 
  def send_getBestSellersCount(self, ):
1417 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1418 
    args = getBestSellersCount_args()
1419 
    args.write(self._oprot)
1420 
    self._oprot.writeMessageEnd()
1421 
    self._oprot.trans.flush()
1422 
 
1423 
  def recv_getBestSellersCount(self, ):
1424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1425 
    if mtype == TMessageType.EXCEPTION:
1426 
      x = TApplicationException()
1427 
      x.read(self._iprot)
1428 
      self._iprot.readMessageEnd()
1429 
      raise x
1430 
    result = getBestSellersCount_result()
1431 
    result.read(self._iprot)
1432 
    self._iprot.readMessageEnd()
1433 
    if result.success is not None:
1434 
      return result.success
1435 
    if result.cex is not None:
1436 
      raise result.cex
1437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1438 
 
1439 
  def getBestDeals(self, ):
1440 
    self.send_getBestDeals()
1441 
    return self.recv_getBestDeals()
1442 
 
1443 
  def send_getBestDeals(self, ):
1444 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1445 
    args = getBestDeals_args()
1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_getBestDeals(self, ):
1451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1452 
    if mtype == TMessageType.EXCEPTION:
1453 
      x = TApplicationException()
1454 
      x.read(self._iprot)
1455 
      self._iprot.readMessageEnd()
1456 
      raise x
1457 
    result = getBestDeals_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
1460 
    if result.success is not None:
1461 
      return result.success
1462 
    if result.isex is not None:
1463 
      raise result.isex
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1465 
 
1466 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1467 
    """
1468 
    Parameters:
1469 
     - beginIndex
1470 
     - totalItems
1471 
     - brand
1472 
     - category
1473 
    """
1474 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1475 
    return self.recv_getBestDealsCatalogIds()
1476 
 
1477 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1478 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1479 
    args = getBestDealsCatalogIds_args()
1480 
    args.beginIndex = beginIndex
1481 
    args.totalItems = totalItems
1482 
    args.brand = brand
1483 
    args.category = category
1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
1488 
  def recv_getBestDealsCatalogIds(self, ):
1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
1495 
    result = getBestDealsCatalogIds_result()
1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
1498 
    if result.success is not None:
1499 
      return result.success
1500 
    if result.cex is not None:
1501 
      raise result.cex
1502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1503 
 
1504 
  def getBestDealsCount(self, ):
1505 
    self.send_getBestDealsCount()
1506 
    return self.recv_getBestDealsCount()
1507 
 
1508 
  def send_getBestDealsCount(self, ):
1509 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1510 
    args = getBestDealsCount_args()
1511 
    args.write(self._oprot)
1512 
    self._oprot.writeMessageEnd()
1513 
    self._oprot.trans.flush()
1514 
 
1515 
  def recv_getBestDealsCount(self, ):
1516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1517 
    if mtype == TMessageType.EXCEPTION:
1518 
      x = TApplicationException()
1519 
      x.read(self._iprot)
1520 
      self._iprot.readMessageEnd()
1521 
      raise x
1522 
    result = getBestDealsCount_result()
1523 
    result.read(self._iprot)
1524 
    self._iprot.readMessageEnd()
1525 
    if result.success is not None:
1526 
      return result.success
1527 
    if result.cex is not None:
1528 
      raise result.cex
1529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1530 
 
1531 
  def getComingSoon(self, ):
1532 
    self.send_getComingSoon()
1533 
    return self.recv_getComingSoon()
1534 
 
1535 
  def send_getComingSoon(self, ):
1536 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1537 
    args = getComingSoon_args()
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_getComingSoon(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = getComingSoon_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
1552 
    if result.success is not None:
1553 
      return result.success
1554 
    if result.isex is not None:
1555 
      raise result.isex
1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1557 
 
1558 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1559 
    """
1560 
    Parameters:
1561 
     - beginIndex
1562 
     - totalItems
1563 
     - brand
1564 
     - category
1565 
    """
1566 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1567 
    return self.recv_getComingSoonCatalogIds()
1568 
 
1569 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1570 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1571 
    args = getComingSoonCatalogIds_args()
1572 
    args.beginIndex = beginIndex
1573 
    args.totalItems = totalItems
1574 
    args.brand = brand
1575 
    args.category = category
1576 
    args.write(self._oprot)
1577 
    self._oprot.writeMessageEnd()
1578 
    self._oprot.trans.flush()
1579 
 
1580 
  def recv_getComingSoonCatalogIds(self, ):
1581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1582 
    if mtype == TMessageType.EXCEPTION:
1583 
      x = TApplicationException()
1584 
      x.read(self._iprot)
1585 
      self._iprot.readMessageEnd()
1586 
      raise x
1587 
    result = getComingSoonCatalogIds_result()
1588 
    result.read(self._iprot)
1589 
    self._iprot.readMessageEnd()
1590 
    if result.success is not None:
1591 
      return result.success
1592 
    if result.cex is not None:
1593 
      raise result.cex
1594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1595 
 
1596 
  def getComingSoonCount(self, ):
1597 
    self.send_getComingSoonCount()
1598 
    return self.recv_getComingSoonCount()
1599 
 
1600 
  def send_getComingSoonCount(self, ):
1601 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1602 
    args = getComingSoonCount_args()
1603 
    args.write(self._oprot)
1604 
    self._oprot.writeMessageEnd()
1605 
    self._oprot.trans.flush()
1606 
 
1607 
  def recv_getComingSoonCount(self, ):
1608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1609 
    if mtype == TMessageType.EXCEPTION:
1610 
      x = TApplicationException()
1611 
      x.read(self._iprot)
1612 
      self._iprot.readMessageEnd()
1613 
      raise x
1614 
    result = getComingSoonCount_result()
1615 
    result.read(self._iprot)
1616 
    self._iprot.readMessageEnd()
1617 
    if result.success is not None:
1618 
      return result.success
1619 
    if result.cex is not None:
1620 
      raise result.cex
1621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1622 
 
1623 
  def getLatestArrivals(self, ):
1624 
    """
1625 
    Returns a list of items sorted in the descending order by start date.
1626 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1627 
    """
1628 
    self.send_getLatestArrivals()
1629 
    return self.recv_getLatestArrivals()
1630 
 
1631 
  def send_getLatestArrivals(self, ):
1632 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1633 
    args = getLatestArrivals_args()
1634 
    args.write(self._oprot)
1635 
    self._oprot.writeMessageEnd()
1636 
    self._oprot.trans.flush()
1637 
 
1638 
  def recv_getLatestArrivals(self, ):
1639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1640 
    if mtype == TMessageType.EXCEPTION:
1641 
      x = TApplicationException()
1642 
      x.read(self._iprot)
1643 
      self._iprot.readMessageEnd()
1644 
      raise x
1645 
    result = getLatestArrivals_result()
1646 
    result.read(self._iprot)
1647 
    self._iprot.readMessageEnd()
1648 
    if result.success is not None:
1649 
      return result.success
1650 
    if result.isex is not None:
1651 
      raise result.isex
1652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1653 
 
1654 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1655 
    """
1656 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1657 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1658 
 
1659 
    Parameters:
1660 
     - beginIndex
1661 
     - totalItems
1662 
     - brand
1663 
     - categories
1664 
    """
1665 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1666 
    return self.recv_getLatestArrivalsCatalogIds()
1667 
 
1668 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1669 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1670 
    args = getLatestArrivalsCatalogIds_args()
1671 
    args.beginIndex = beginIndex
1672 
    args.totalItems = totalItems
1673 
    args.brand = brand
1674 
    args.categories = categories
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getLatestArrivalsCatalogIds(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = getLatestArrivalsCatalogIds_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
1689 
    if result.success is not None:
1690 
      return result.success
1691 
    if result.cex is not None:
1692 
      raise result.cex
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1694 
 
1695 
  def getLatestArrivalsCount(self, ):
1696 
    """
1697 
    Get the total number of latest arrivals we are willing to show.
1698 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1699 
    """
1700 
    self.send_getLatestArrivalsCount()
1701 
    return self.recv_getLatestArrivalsCount()
1702 
 
1703 
  def send_getLatestArrivalsCount(self, ):
1704 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1705 
    args = getLatestArrivalsCount_args()
1706 
    args.write(self._oprot)
1707 
    self._oprot.writeMessageEnd()
1708 
    self._oprot.trans.flush()
1709 
 
1710 
  def recv_getLatestArrivalsCount(self, ):
1711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1712 
    if mtype == TMessageType.EXCEPTION:
1713 
      x = TApplicationException()
1714 
      x.read(self._iprot)
1715 
      self._iprot.readMessageEnd()
1716 
      raise x
1717 
    result = getLatestArrivalsCount_result()
1718 
    result.read(self._iprot)
1719 
    self._iprot.readMessageEnd()
1720 
    if result.success is not None:
1721 
      return result.success
1722 
    if result.cex is not None:
1723 
      raise result.cex
1724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1725 
 
1726 
  def generateNewEntityID(self, ):
1727 
    self.send_generateNewEntityID()
1728 
    return self.recv_generateNewEntityID()
1729 
 
1730 
  def send_generateNewEntityID(self, ):
1731 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1732 
    args = generateNewEntityID_args()
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_generateNewEntityID(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = generateNewEntityID_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
1747 
    if result.success is not None:
1748 
      return result.success
1749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1750 
 
1751 
  def addCategory(self, category):
1752 
    """
1753 
    All category related functions
1754 
 
1755 
    Parameters:
1756 
     - category
1757 
    """
1758 
    self.send_addCategory(category)
1759 
    return self.recv_addCategory()
1760 
 
1761 
  def send_addCategory(self, category):
1762 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1763 
    args = addCategory_args()
1764 
    args.category = category
1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1769 
  def recv_addCategory(self, ):
1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1776 
    result = addCategory_result()
1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
1779 
    if result.success is not None:
1780 
      return result.success
1781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1782 
 
1783 
  def getCategory(self, id):
1784 
    """
1785 
    Parameters:
1786 
     - id
1787 
    """
1788 
    self.send_getCategory(id)
1789 
    return self.recv_getCategory()
1790 
 
1791 
  def send_getCategory(self, id):
1792 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1793 
    args = getCategory_args()
1794 
    args.id = id
1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_getCategory(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = getCategory_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
1809 
    if result.success is not None:
1810 
      return result.success
1811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1812 
 
1813 
  def getAllCategories(self, ):
1814 
    self.send_getAllCategories()
1815 
    return self.recv_getAllCategories()
1816 
 
1817 
  def send_getAllCategories(self, ):
1818 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1819 
    args = getAllCategories_args()
1820 
    args.write(self._oprot)
1821 
    self._oprot.writeMessageEnd()
1822 
    self._oprot.trans.flush()
1823 
 
1824 
  def recv_getAllCategories(self, ):
1825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1826 
    if mtype == TMessageType.EXCEPTION:
1827 
      x = TApplicationException()
1828 
      x.read(self._iprot)
1829 
      self._iprot.readMessageEnd()
1830 
      raise x
1831 
    result = getAllCategories_result()
1832 
    result.read(self._iprot)
1833 
    self._iprot.readMessageEnd()
1834 
    if result.success is not None:
1835 
      return result.success
1836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1837 
 
1838 
  def getAllSimilarItems(self, itemId):
1839 
    """
1840 
    Returns the list of similar items.
1841 
 
1842 
    Parameters:
1843 
     - itemId
1844 
    """
1845 
    self.send_getAllSimilarItems(itemId)
1846 
    return self.recv_getAllSimilarItems()
1847 
 
1848 
  def send_getAllSimilarItems(self, itemId):
1849 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1850 
    args = getAllSimilarItems_args()
1851 
    args.itemId = itemId
1852 
    args.write(self._oprot)
1853 
    self._oprot.writeMessageEnd()
1854 
    self._oprot.trans.flush()
1855 
 
1856 
  def recv_getAllSimilarItems(self, ):
1857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1858 
    if mtype == TMessageType.EXCEPTION:
1859 
      x = TApplicationException()
1860 
      x.read(self._iprot)
1861 
      self._iprot.readMessageEnd()
1862 
      raise x
1863 
    result = getAllSimilarItems_result()
1864 
    result.read(self._iprot)
1865 
    self._iprot.readMessageEnd()
1866 
    if result.success is not None:
1867 
      return result.success
1868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1869 
 
1870 
  def addSimilarItem(self, itemId, catalogItemId):
1871 
    """
1872 
    Adds similar item.
1873 
 
1874 
    Parameters:
1875 
     - itemId
1876 
     - catalogItemId
1877 
    """
1878 
    self.send_addSimilarItem(itemId, catalogItemId)
1879 
    return self.recv_addSimilarItem()
1880 
 
1881 
  def send_addSimilarItem(self, itemId, catalogItemId):
1882 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1883 
    args = addSimilarItem_args()
1884 
    args.itemId = itemId
1885 
    args.catalogItemId = catalogItemId
1886 
    args.write(self._oprot)
1887 
    self._oprot.writeMessageEnd()
1888 
    self._oprot.trans.flush()
1889 
 
1890 
  def recv_addSimilarItem(self, ):
1891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1892 
    if mtype == TMessageType.EXCEPTION:
1893 
      x = TApplicationException()
1894 
      x.read(self._iprot)
1895 
      self._iprot.readMessageEnd()
1896 
      raise x
1897 
    result = addSimilarItem_result()
1898 
    result.read(self._iprot)
1899 
    self._iprot.readMessageEnd()
1900 
    if result.success is not None:
1901 
      return result.success
1902 
    if result.cex is not None:
1903 
      raise result.cex
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1905 
 
6512 kshitij.so 1906 
  def addTag(self, displayName, itemId):
1907 
    """
1908 
    Tag Related
1909 
 
1910 
    Parameters:
1911 
     - displayName
1912 
     - itemId
1913 
    """
1914 
    self.send_addTag(displayName, itemId)
1915 
    return self.recv_addTag()
1916 
 
1917 
  def send_addTag(self, displayName, itemId):
1918 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1919 
    args = addTag_args()
1920 
    args.displayName = displayName
1921 
    args.itemId = itemId
1922 
    args.write(self._oprot)
1923 
    self._oprot.writeMessageEnd()
1924 
    self._oprot.trans.flush()
1925 
 
1926 
  def recv_addTag(self, ):
1927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1928 
    if mtype == TMessageType.EXCEPTION:
1929 
      x = TApplicationException()
1930 
      x.read(self._iprot)
1931 
      self._iprot.readMessageEnd()
1932 
      raise x
1933 
    result = addTag_result()
1934 
    result.read(self._iprot)
1935 
    self._iprot.readMessageEnd()
1936 
    if result.success is not None:
1937 
      return result.success
1938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1939 
 
1940 
  def deleteEntityTag(self, displayName, itemId):
1941 
    """
1942 
    Parameters:
1943 
     - displayName
1944 
     - itemId
1945 
    """
1946 
    self.send_deleteEntityTag(displayName, itemId)
1947 
    return self.recv_deleteEntityTag()
1948 
 
1949 
  def send_deleteEntityTag(self, displayName, itemId):
1950 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1951 
    args = deleteEntityTag_args()
1952 
    args.displayName = displayName
1953 
    args.itemId = itemId
1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
1958 
  def recv_deleteEntityTag(self, ):
1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
1965 
    result = deleteEntityTag_result()
1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
1968 
    if result.success is not None:
1969 
      return result.success
1970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1971 
 
1972 
  def deleteTag(self, displayName):
1973 
    """
1974 
    Parameters:
1975 
     - displayName
1976 
    """
1977 
    self.send_deleteTag(displayName)
1978 
    return self.recv_deleteTag()
1979 
 
1980 
  def send_deleteTag(self, displayName):
1981 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1982 
    args = deleteTag_args()
1983 
    args.displayName = displayName
1984 
    args.write(self._oprot)
1985 
    self._oprot.writeMessageEnd()
1986 
    self._oprot.trans.flush()
1987 
 
1988 
  def recv_deleteTag(self, ):
1989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1990 
    if mtype == TMessageType.EXCEPTION:
1991 
      x = TApplicationException()
1992 
      x.read(self._iprot)
1993 
      self._iprot.readMessageEnd()
1994 
      raise x
1995 
    result = deleteTag_result()
1996 
    result.read(self._iprot)
1997 
    self._iprot.readMessageEnd()
1998 
    if result.success is not None:
1999 
      return result.success
2000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2001 
 
2002 
  def getAllTags(self, ):
2003 
    self.send_getAllTags()
2004 
    return self.recv_getAllTags()
2005 
 
2006 
  def send_getAllTags(self, ):
2007 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2008 
    args = getAllTags_args()
2009 
    args.write(self._oprot)
2010 
    self._oprot.writeMessageEnd()
2011 
    self._oprot.trans.flush()
2012 
 
2013 
  def recv_getAllTags(self, ):
2014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2015 
    if mtype == TMessageType.EXCEPTION:
2016 
      x = TApplicationException()
2017 
      x.read(self._iprot)
2018 
      self._iprot.readMessageEnd()
2019 
      raise x
2020 
    result = getAllTags_result()
2021 
    result.read(self._iprot)
2022 
    self._iprot.readMessageEnd()
2023 
    if result.success is not None:
2024 
      return result.success
2025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2026 
 
2027 
  def getAllEntitiesByTagName(self, displayName):
2028 
    """
2029 
    Parameters:
2030 
     - displayName
2031 
    """
2032 
    self.send_getAllEntitiesByTagName(displayName)
2033 
    return self.recv_getAllEntitiesByTagName()
2034 
 
2035 
  def send_getAllEntitiesByTagName(self, displayName):
2036 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2037 
    args = getAllEntitiesByTagName_args()
2038 
    args.displayName = displayName
2039 
    args.write(self._oprot)
2040 
    self._oprot.writeMessageEnd()
2041 
    self._oprot.trans.flush()
2042 
 
2043 
  def recv_getAllEntitiesByTagName(self, ):
2044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2045 
    if mtype == TMessageType.EXCEPTION:
2046 
      x = TApplicationException()
2047 
      x.read(self._iprot)
2048 
      self._iprot.readMessageEnd()
2049 
      raise x
2050 
    result = getAllEntitiesByTagName_result()
2051 
    result.read(self._iprot)
2052 
    self._iprot.readMessageEnd()
2053 
    if result.success is not None:
2054 
      return result.success
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2056 
 
6845 amit.gupta 2057 
  def getAllEntityTags(self, ):
2058 
    self.send_getAllEntityTags()
2059 
    return self.recv_getAllEntityTags()
2060 
 
2061 
  def send_getAllEntityTags(self, ):
2062 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2063 
    args = getAllEntityTags_args()
2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
2068 
  def recv_getAllEntityTags(self, ):
2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
2075 
    result = getAllEntityTags_result()
2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
2078 
    if result.success is not None:
2079 
      return result.success
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2081 
 
6850 kshitij.so 2082 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2083 
    """
2084 
    Parameters:
2085 
     - bannerName
2086 
     - imageName
2087 
     - link
2088 
     - priority
2089 
     - isActive
2090 
     - hasMap
2091 
    """
2092 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2093 
    return self.recv_addBanner()
2094 
 
2095 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2096 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2097 
    args = addBanner_args()
2098 
    args.bannerName = bannerName
2099 
    args.imageName = imageName
2100 
    args.link = link
2101 
    args.priority = priority
2102 
    args.isActive = isActive
2103 
    args.hasMap = hasMap
2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
2108 
  def recv_addBanner(self, ):
2109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2110 
    if mtype == TMessageType.EXCEPTION:
2111 
      x = TApplicationException()
2112 
      x.read(self._iprot)
2113 
      self._iprot.readMessageEnd()
2114 
      raise x
2115 
    result = addBanner_result()
2116 
    result.read(self._iprot)
2117 
    self._iprot.readMessageEnd()
2118 
    if result.success is not None:
2119 
      return result.success
2120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2121 
 
2122 
  def getAllBanners(self, ):
2123 
    self.send_getAllBanners()
2124 
    return self.recv_getAllBanners()
2125 
 
2126 
  def send_getAllBanners(self, ):
2127 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2128 
    args = getAllBanners_args()
2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
2133 
  def recv_getAllBanners(self, ):
2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
2140 
    result = getAllBanners_result()
2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
2143 
    if result.success is not None:
2144 
      return result.success
2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2146 
 
2147 
  def deleteBanner(self, bannerName):
2148 
    """
2149 
    Parameters:
2150 
     - bannerName
2151 
    """
2152 
    self.send_deleteBanner(bannerName)
2153 
    return self.recv_deleteBanner()
2154 
 
2155 
  def send_deleteBanner(self, bannerName):
2156 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2157 
    args = deleteBanner_args()
2158 
    args.bannerName = bannerName
2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
2163 
  def recv_deleteBanner(self, ):
2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
2170 
    result = deleteBanner_result()
2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
2173 
    if result.success is not None:
2174 
      return result.success
2175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2176 
 
2177 
  def getBannerDetails(self, bannerName):
2178 
    """
2179 
    Parameters:
2180 
     - bannerName
2181 
    """
2182 
    self.send_getBannerDetails(bannerName)
2183 
    return self.recv_getBannerDetails()
2184 
 
2185 
  def send_getBannerDetails(self, bannerName):
2186 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2187 
    args = getBannerDetails_args()
2188 
    args.bannerName = bannerName
2189 
    args.write(self._oprot)
2190 
    self._oprot.writeMessageEnd()
2191 
    self._oprot.trans.flush()
2192 
 
2193 
  def recv_getBannerDetails(self, ):
2194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2195 
    if mtype == TMessageType.EXCEPTION:
2196 
      x = TApplicationException()
2197 
      x.read(self._iprot)
2198 
      self._iprot.readMessageEnd()
2199 
      raise x
2200 
    result = getBannerDetails_result()
2201 
    result.read(self._iprot)
2202 
    self._iprot.readMessageEnd()
2203 
    if result.success is not None:
2204 
      return result.success
2205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2206 
 
2207 
  def getActiveBanners(self, ):
2208 
    self.send_getActiveBanners()
2209 
    return self.recv_getActiveBanners()
2210 
 
2211 
  def send_getActiveBanners(self, ):
2212 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2213 
    args = getActiveBanners_args()
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_getActiveBanners(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = getActiveBanners_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
2228 
    if result.success is not None:
2229 
      return result.success
2230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2231 
 
6849 kshitij.so 2232 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2233 
    """
2234 
    Parameters:
2235 
     - bannerName
2236 
     - mapLink
2237 
     - coordinates
2238 
    """
2239 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2240 
    return self.recv_addBannerMap()
2241 
 
2242 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2243 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2244 
    args = addBannerMap_args()
2245 
    args.bannerName = bannerName
2246 
    args.mapLink = mapLink
2247 
    args.coordinates = coordinates
2248 
    args.write(self._oprot)
2249 
    self._oprot.writeMessageEnd()
2250 
    self._oprot.trans.flush()
2251 
 
2252 
  def recv_addBannerMap(self, ):
2253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2254 
    if mtype == TMessageType.EXCEPTION:
2255 
      x = TApplicationException()
2256 
      x.read(self._iprot)
2257 
      self._iprot.readMessageEnd()
2258 
      raise x
2259 
    result = addBannerMap_result()
2260 
    result.read(self._iprot)
2261 
    self._iprot.readMessageEnd()
2262 
    if result.success is not None:
2263 
      return result.success
2264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2265 
 
2266 
  def deleteBannerMap(self, bannerName):
2267 
    """
2268 
    Parameters:
2269 
     - bannerName
2270 
    """
2271 
    self.send_deleteBannerMap(bannerName)
2272 
    return self.recv_deleteBannerMap()
2273 
 
2274 
  def send_deleteBannerMap(self, bannerName):
2275 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2276 
    args = deleteBannerMap_args()
2277 
    args.bannerName = bannerName
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_deleteBannerMap(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = deleteBannerMap_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
2292 
    if result.success is not None:
2293 
      return result.success
2294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2295 
 
2296 
  def getBannerMapDetails(self, bannerName):
2297 
    """
2298 
    Parameters:
2299 
     - bannerName
2300 
    """
2301 
    self.send_getBannerMapDetails(bannerName)
2302 
    return self.recv_getBannerMapDetails()
2303 
 
2304 
  def send_getBannerMapDetails(self, bannerName):
2305 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2306 
    args = getBannerMapDetails_args()
2307 
    args.bannerName = bannerName
2308 
    args.write(self._oprot)
2309 
    self._oprot.writeMessageEnd()
2310 
    self._oprot.trans.flush()
2311 
 
2312 
  def recv_getBannerMapDetails(self, ):
2313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2314 
    if mtype == TMessageType.EXCEPTION:
2315 
      x = TApplicationException()
2316 
      x.read(self._iprot)
2317 
      self._iprot.readMessageEnd()
2318 
      raise x
2319 
    result = getBannerMapDetails_result()
2320 
    result.read(self._iprot)
2321 
    self._iprot.readMessageEnd()
2322 
    if result.success is not None:
2323 
      return result.success
2324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2325 
 
5944 mandeep.dh 2326 
  def deleteSimilarItem(self, itemId, catalogItemId):
2327 
    """
2328 
    Delete similar item.
2329 
 
2330 
    Parameters:
2331 
     - itemId
2332 
     - catalogItemId
2333 
    """
2334 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2335 
    return self.recv_deleteSimilarItem()
2336 
 
2337 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2338 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2339 
    args = deleteSimilarItem_args()
2340 
    args.itemId = itemId
2341 
    args.catalogItemId = catalogItemId
2342 
    args.write(self._oprot)
2343 
    self._oprot.writeMessageEnd()
2344 
    self._oprot.trans.flush()
2345 
 
2346 
  def recv_deleteSimilarItem(self, ):
2347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2348 
    if mtype == TMessageType.EXCEPTION:
2349 
      x = TApplicationException()
2350 
      x.read(self._iprot)
2351 
      self._iprot.readMessageEnd()
2352 
      raise x
2353 
    result = deleteSimilarItem_result()
2354 
    result.read(self._iprot)
2355 
    self._iprot.readMessageEnd()
2356 
    if result.success is not None:
2357 
      return result.success
2358 
    if result.cex is not None:
2359 
      raise result.cex
2360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2361 
 
2362 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2363 
    """
2364 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2365 
    If yes, returns the itemId else returns 0
2366 
 
2367 
    Parameters:
2368 
     - brand
2369 
     - modelNumber
2370 
     - modelName
2371 
     - color
2372 
    """
2373 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2374 
    return self.recv_checkSimilarItem()
2375 
 
2376 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2377 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2378 
    args = checkSimilarItem_args()
2379 
    args.brand = brand
2380 
    args.modelNumber = modelNumber
2381 
    args.modelName = modelName
2382 
    args.color = color
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_checkSimilarItem(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = checkSimilarItem_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
2397 
    if result.success is not None:
2398 
      return result.success
2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2400 
 
2401 
  def validateRiskyStatus(self, itemId):
2402 
    """
2403 
    Check wether item is risky and change status if inventory is not available for risky items
2404 
 
2405 
    Parameters:
2406 
     - itemId
2407 
    """
2408 
    self.send_validateRiskyStatus(itemId)
2409 
    self.recv_validateRiskyStatus()
2410 
 
2411 
  def send_validateRiskyStatus(self, itemId):
2412 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2413 
    args = validateRiskyStatus_args()
2414 
    args.itemId = itemId
2415 
    args.write(self._oprot)
2416 
    self._oprot.writeMessageEnd()
2417 
    self._oprot.trans.flush()
2418 
 
2419 
  def recv_validateRiskyStatus(self, ):
2420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2421 
    if mtype == TMessageType.EXCEPTION:
2422 
      x = TApplicationException()
2423 
      x.read(self._iprot)
2424 
      self._iprot.readMessageEnd()
2425 
      raise x
2426 
    result = validateRiskyStatus_result()
2427 
    result.read(self._iprot)
2428 
    self._iprot.readMessageEnd()
2429 
    return
2430 
 
2431 
  def changeItemRiskyFlag(self, itemId, risky):
2432 
    """
2433 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2434 
 
2435 
    Parameters:
2436 
     - itemId
2437 
     - risky
2438 
    """
2439 
    self.send_changeItemRiskyFlag(itemId, risky)
2440 
    self.recv_changeItemRiskyFlag()
2441 
 
2442 
  def send_changeItemRiskyFlag(self, itemId, risky):
2443 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2444 
    args = changeItemRiskyFlag_args()
2445 
    args.itemId = itemId
2446 
    args.risky = risky
2447 
    args.write(self._oprot)
2448 
    self._oprot.writeMessageEnd()
2449 
    self._oprot.trans.flush()
2450 
 
2451 
  def recv_changeItemRiskyFlag(self, ):
2452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2453 
    if mtype == TMessageType.EXCEPTION:
2454 
      x = TApplicationException()
2455 
      x.read(self._iprot)
2456 
      self._iprot.readMessageEnd()
2457 
      raise x
2458 
    result = changeItemRiskyFlag_result()
2459 
    result.read(self._iprot)
2460 
    self._iprot.readMessageEnd()
2461 
    return
2462 
 
2463 
  def getItemsByRiskyFlag(self, ):
2464 
    """
2465 
    Returns list of items marked as risky.
2466 
    """
2467 
    self.send_getItemsByRiskyFlag()
2468 
    return self.recv_getItemsByRiskyFlag()
2469 
 
2470 
  def send_getItemsByRiskyFlag(self, ):
2471 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2472 
    args = getItemsByRiskyFlag_args()
2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
2477 
  def recv_getItemsByRiskyFlag(self, ):
2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
2484 
    result = getItemsByRiskyFlag_result()
2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
2487 
    if result.success is not None:
2488 
      return result.success
2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2490 
 
2491 
  def getItemsForMasterSheet(self, category, brand):
2492 
    """
2493 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2494 
 
2495 
    Parameters:
2496 
     - category
2497 
     - brand
2498 
    """
2499 
    self.send_getItemsForMasterSheet(category, brand)
2500 
    return self.recv_getItemsForMasterSheet()
2501 
 
2502 
  def send_getItemsForMasterSheet(self, category, brand):
2503 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2504 
    args = getItemsForMasterSheet_args()
2505 
    args.category = category
2506 
    args.brand = brand
2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
2511 
  def recv_getItemsForMasterSheet(self, ):
2512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2513 
    if mtype == TMessageType.EXCEPTION:
2514 
      x = TApplicationException()
2515 
      x.read(self._iprot)
2516 
      self._iprot.readMessageEnd()
2517 
      raise x
2518 
    result = getItemsForMasterSheet_result()
2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
2521 
    if result.success is not None:
2522 
      return result.success
2523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2524 
 
2525 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2526 
    """
2527 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2528 
 
2529 
    Parameters:
2530 
     - beginIndex
2531 
     - totalItems
2532 
     - itemId
2533 
    """
2534 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2535 
    return self.recv_getSimilarItemsCatalogIds()
2536 
 
2537 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2538 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2539 
    args = getSimilarItemsCatalogIds_args()
2540 
    args.beginIndex = beginIndex
2541 
    args.totalItems = totalItems
2542 
    args.itemId = itemId
2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_getSimilarItemsCatalogIds(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = getSimilarItemsCatalogIds_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2560 
 
2561 
  def addProductNotification(self, itemId, email):
2562 
    """
2563 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2564 
 
2565 
    Parameters:
2566 
     - itemId
2567 
     - email
2568 
    """
2569 
    self.send_addProductNotification(itemId, email)
2570 
    return self.recv_addProductNotification()
2571 
 
2572 
  def send_addProductNotification(self, itemId, email):
2573 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2574 
    args = addProductNotification_args()
2575 
    args.itemId = itemId
2576 
    args.email = email
2577 
    args.write(self._oprot)
2578 
    self._oprot.writeMessageEnd()
2579 
    self._oprot.trans.flush()
2580 
 
2581 
  def recv_addProductNotification(self, ):
2582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2583 
    if mtype == TMessageType.EXCEPTION:
2584 
      x = TApplicationException()
2585 
      x.read(self._iprot)
2586 
      self._iprot.readMessageEnd()
2587 
      raise x
2588 
    result = addProductNotification_result()
2589 
    result.read(self._iprot)
2590 
    self._iprot.readMessageEnd()
2591 
    if result.success is not None:
2592 
      return result.success
2593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2594 
 
2595 
  def sendProductNotifications(self, ):
2596 
    """
2597 
    Send the product notifications to the users for items which has stock.
2598 
    """
2599 
    self.send_sendProductNotifications()
2600 
    return self.recv_sendProductNotifications()
2601 
 
2602 
  def send_sendProductNotifications(self, ):
2603 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2604 
    args = sendProductNotifications_args()
2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
2609 
  def recv_sendProductNotifications(self, ):
2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
2616 
    result = sendProductNotifications_result()
2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    if result.success is not None:
2620 
      return result.success
2621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2622 
 
2623 
  def getAllBrandsByCategory(self, categoryId):
2624 
    """
2625 
    Returns list of brand names for a given category Id
2626 
 
2627 
    Parameters:
2628 
     - categoryId
2629 
    """
2630 
    self.send_getAllBrandsByCategory(categoryId)
2631 
    return self.recv_getAllBrandsByCategory()
2632 
 
2633 
  def send_getAllBrandsByCategory(self, categoryId):
2634 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2635 
    args = getAllBrandsByCategory_args()
2636 
    args.categoryId = categoryId
2637 
    args.write(self._oprot)
2638 
    self._oprot.writeMessageEnd()
2639 
    self._oprot.trans.flush()
2640 
 
2641 
  def recv_getAllBrandsByCategory(self, ):
2642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2643 
    if mtype == TMessageType.EXCEPTION:
2644 
      x = TApplicationException()
2645 
      x.read(self._iprot)
2646 
      self._iprot.readMessageEnd()
2647 
      raise x
2648 
    result = getAllBrandsByCategory_result()
2649 
    result.read(self._iprot)
2650 
    self._iprot.readMessageEnd()
2651 
    if result.success is not None:
2652 
      return result.success
2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2654 
 
2655 
  def getAllBrands(self, ):
2656 
    """
2657 
    Returns list of brand names
2658 
    """
2659 
    self.send_getAllBrands()
2660 
    return self.recv_getAllBrands()
2661 
 
2662 
  def send_getAllBrands(self, ):
2663 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2664 
    args = getAllBrands_args()
2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
2669 
  def recv_getAllBrands(self, ):
2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
2676 
    result = getAllBrands_result()
2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    if result.success is not None:
2680 
      return result.success
2681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2682 
 
2683 
  def getAllSources(self, ):
2684 
    """
2685 
    Return list of all sources
2686 
    """
2687 
    self.send_getAllSources()
2688 
    return self.recv_getAllSources()
2689 
 
2690 
  def send_getAllSources(self, ):
2691 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2692 
    args = getAllSources_args()
2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
2697 
  def recv_getAllSources(self, ):
2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
2704 
    result = getAllSources_result()
2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
2707 
    if result.success is not None:
2708 
      return result.success
2709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2710 
 
2711 
  def getItemPricingBySource(self, itemId, sourceId):
2712 
    """
2713 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2714 
 
2715 
    Parameters:
2716 
     - itemId
2717 
     - sourceId
2718 
    """
2719 
    self.send_getItemPricingBySource(itemId, sourceId)
2720 
    return self.recv_getItemPricingBySource()
2721 
 
2722 
  def send_getItemPricingBySource(self, itemId, sourceId):
2723 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2724 
    args = getItemPricingBySource_args()
2725 
    args.itemId = itemId
2726 
    args.sourceId = sourceId
2727 
    args.write(self._oprot)
2728 
    self._oprot.writeMessageEnd()
2729 
    self._oprot.trans.flush()
2730 
 
2731 
  def recv_getItemPricingBySource(self, ):
2732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2733 
    if mtype == TMessageType.EXCEPTION:
2734 
      x = TApplicationException()
2735 
      x.read(self._iprot)
2736 
      self._iprot.readMessageEnd()
2737 
      raise x
2738 
    result = getItemPricingBySource_result()
2739 
    result.read(self._iprot)
2740 
    self._iprot.readMessageEnd()
2741 
    if result.success is not None:
2742 
      return result.success
2743 
    if result.cex is not None:
2744 
      raise result.cex
2745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2746 
 
2747 
  def addSourceItemPricing(self, sourceItemPricing):
2748 
    """
2749 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2750 
    If item is not found or source is not found, it will throw exception.
2751 
 
2752 
    Parameters:
2753 
     - sourceItemPricing
2754 
    """
2755 
    self.send_addSourceItemPricing(sourceItemPricing)
2756 
    self.recv_addSourceItemPricing()
2757 
 
2758 
  def send_addSourceItemPricing(self, sourceItemPricing):
2759 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2760 
    args = addSourceItemPricing_args()
2761 
    args.sourceItemPricing = sourceItemPricing
2762 
    args.write(self._oprot)
2763 
    self._oprot.writeMessageEnd()
2764 
    self._oprot.trans.flush()
2765 
 
2766 
  def recv_addSourceItemPricing(self, ):
2767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2768 
    if mtype == TMessageType.EXCEPTION:
2769 
      x = TApplicationException()
2770 
      x.read(self._iprot)
2771 
      self._iprot.readMessageEnd()
2772 
      raise x
2773 
    result = addSourceItemPricing_result()
2774 
    result.read(self._iprot)
2775 
    self._iprot.readMessageEnd()
2776 
    if result.cex is not None:
2777 
      raise result.cex
2778 
    return
2779 
 
2780 
  def getAllSourcePricing(self, itemId):
2781 
    """
2782 
    Returns the list of source pricing information of an item.
2783 
    Raises an exception if item not found corresponding to itemId
2784 
 
2785 
    Parameters:
2786 
     - itemId
2787 
    """
2788 
    self.send_getAllSourcePricing(itemId)
2789 
    return self.recv_getAllSourcePricing()
2790 
 
2791 
  def send_getAllSourcePricing(self, itemId):
2792 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2793 
    args = getAllSourcePricing_args()
2794 
    args.itemId = itemId
2795 
    args.write(self._oprot)
2796 
    self._oprot.writeMessageEnd()
2797 
    self._oprot.trans.flush()
2798 
 
2799 
  def recv_getAllSourcePricing(self, ):
2800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2801 
    if mtype == TMessageType.EXCEPTION:
2802 
      x = TApplicationException()
2803 
      x.read(self._iprot)
2804 
      self._iprot.readMessageEnd()
2805 
      raise x
2806 
    result = getAllSourcePricing_result()
2807 
    result.read(self._iprot)
2808 
    self._iprot.readMessageEnd()
2809 
    if result.success is not None:
2810 
      return result.success
2811 
    if result.cex is not None:
2812 
      raise result.cex
2813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2814 
 
2815 
  def getItemForSource(self, item_id, sourceId):
2816 
    """
2817 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2818 
 
2819 
    Parameters:
2820 
     - item_id
2821 
     - sourceId
2822 
    """
2823 
    self.send_getItemForSource(item_id, sourceId)
2824 
    return self.recv_getItemForSource()
2825 
 
2826 
  def send_getItemForSource(self, item_id, sourceId):
2827 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2828 
    args = getItemForSource_args()
2829 
    args.item_id = item_id
2830 
    args.sourceId = sourceId
2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2835 
  def recv_getItemForSource(self, ):
2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2842 
    result = getItemForSource_result()
2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
2845 
    if result.success is not None:
2846 
      return result.success
2847 
    if result.cex is not None:
2848 
      raise result.cex
2849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2850 
 
2851 
  def searchItemsInRange(self, searchTerms, offset, limit):
2852 
    """
2853 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2854 
 
2855 
    Parameters:
2856 
     - searchTerms
2857 
     - offset
2858 
     - limit
2859 
    """
2860 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2861 
    return self.recv_searchItemsInRange()
2862 
 
2863 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2864 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2865 
    args = searchItemsInRange_args()
2866 
    args.searchTerms = searchTerms
2867 
    args.offset = offset
2868 
    args.limit = limit
2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
2873 
  def recv_searchItemsInRange(self, ):
2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
2880 
    result = searchItemsInRange_result()
2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
2883 
    if result.success is not None:
2884 
      return result.success
2885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2886 
 
2887 
  def getSearchResultCount(self, searchTerms):
2888 
    """
2889 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2890 
 
2891 
    Parameters:
2892 
     - searchTerms
2893 
    """
2894 
    self.send_getSearchResultCount(searchTerms)
2895 
    return self.recv_getSearchResultCount()
2896 
 
2897 
  def send_getSearchResultCount(self, searchTerms):
2898 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2899 
    args = getSearchResultCount_args()
2900 
    args.searchTerms = searchTerms
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getSearchResultCount(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getSearchResultCount_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2918 
 
2919 
  def getProductNotifications(self, startDateTime):
2920 
    """
2921 
    Returns a list of product notifications added after a supplied datetime
2922 
 
2923 
    Parameters:
2924 
     - startDateTime
2925 
    """
2926 
    self.send_getProductNotifications(startDateTime)
2927 
    return self.recv_getProductNotifications()
2928 
 
2929 
  def send_getProductNotifications(self, startDateTime):
2930 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2931 
    args = getProductNotifications_args()
2932 
    args.startDateTime = startDateTime
2933 
    args.write(self._oprot)
2934 
    self._oprot.writeMessageEnd()
2935 
    self._oprot.trans.flush()
2936 
 
2937 
  def recv_getProductNotifications(self, ):
2938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2939 
    if mtype == TMessageType.EXCEPTION:
2940 
      x = TApplicationException()
2941 
      x.read(self._iprot)
2942 
      self._iprot.readMessageEnd()
2943 
      raise x
2944 
    result = getProductNotifications_result()
2945 
    result.read(self._iprot)
2946 
    self._iprot.readMessageEnd()
2947 
    if result.success is not None:
2948 
      return result.success
2949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2950 
 
7897 amar.kumar 2951 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2952 
    """
2953 
    Returns a list of count of requests for product notification against each item
2954 
 
2955 
    Parameters:
2956 
     - startDateTime
7897 amar.kumar 2957 
     - categoryId
5944 mandeep.dh 2958 
    """
7897 amar.kumar 2959 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 2960 
    return self.recv_getProductNotificationRequestCount()
2961 
 
7897 amar.kumar 2962 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2963 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2964 
    args = getProductNotificationRequestCount_args()
2965 
    args.startDateTime = startDateTime
7897 amar.kumar 2966 
    args.categoryId = categoryId
5944 mandeep.dh 2967 
    args.write(self._oprot)
2968 
    self._oprot.writeMessageEnd()
2969 
    self._oprot.trans.flush()
2970 
 
2971 
  def recv_getProductNotificationRequestCount(self, ):
2972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2973 
    if mtype == TMessageType.EXCEPTION:
2974 
      x = TApplicationException()
2975 
      x.read(self._iprot)
2976 
      self._iprot.readMessageEnd()
2977 
      raise x
2978 
    result = getProductNotificationRequestCount_result()
2979 
    result.read(self._iprot)
2980 
    self._iprot.readMessageEnd()
2981 
    if result.success is not None:
2982 
      return result.success
2983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2984 
 
2985 
  def addAuthorizationLog(self, itemId, username, reason):
2986 
    """
2987 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2988 
 
2989 
    Parameters:
2990 
     - itemId
2991 
     - username
2992 
     - reason
2993 
    """
2994 
    self.send_addAuthorizationLog(itemId, username, reason)
2995 
    return self.recv_addAuthorizationLog()
2996 
 
2997 
  def send_addAuthorizationLog(self, itemId, username, reason):
2998 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2999 
    args = addAuthorizationLog_args()
3000 
    args.itemId = itemId
3001 
    args.username = username
3002 
    args.reason = reason
3003 
    args.write(self._oprot)
3004 
    self._oprot.writeMessageEnd()
3005 
    self._oprot.trans.flush()
3006 
 
3007 
  def recv_addAuthorizationLog(self, ):
3008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3009 
    if mtype == TMessageType.EXCEPTION:
3010 
      x = TApplicationException()
3011 
      x.read(self._iprot)
3012 
      self._iprot.readMessageEnd()
3013 
      raise x
3014 
    result = addAuthorizationLog_result()
3015 
    result.read(self._iprot)
3016 
    self._iprot.readMessageEnd()
3017 
    if result.success is not None:
3018 
      return result.success
3019 
    if result.cex is not None:
3020 
      raise result.cex
3021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3022 
 
3023 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3024 
    """
3025 
    Parameters:
3026 
     - catalog_item_id
3027 
     - voucherType
3028 
     - voucherAmount
3029 
    """
3030 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3031 
    return self.recv_addupdateVoucherForItem()
3032 
 
3033 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3034 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3035 
    args = addupdateVoucherForItem_args()
3036 
    args.catalog_item_id = catalog_item_id
3037 
    args.voucherType = voucherType
3038 
    args.voucherAmount = voucherAmount
3039 
    args.write(self._oprot)
3040 
    self._oprot.writeMessageEnd()
3041 
    self._oprot.trans.flush()
3042 
 
3043 
  def recv_addupdateVoucherForItem(self, ):
3044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3045 
    if mtype == TMessageType.EXCEPTION:
3046 
      x = TApplicationException()
3047 
      x.read(self._iprot)
3048 
      self._iprot.readMessageEnd()
3049 
      raise x
3050 
    result = addupdateVoucherForItem_result()
3051 
    result.read(self._iprot)
3052 
    self._iprot.readMessageEnd()
3053 
    if result.success is not None:
3054 
      return result.success
3055 
    if result.cex is not None:
3056 
      raise result.cex
3057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3058 
 
3059 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3060 
    """
3061 
    Parameters:
3062 
     - catalog_item_id
3063 
     - voucherType
3064 
    """
3065 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3066 
    return self.recv_deleteVoucherForItem()
3067 
 
3068 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3069 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3070 
    args = deleteVoucherForItem_args()
3071 
    args.catalog_item_id = catalog_item_id
3072 
    args.voucherType = voucherType
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_deleteVoucherForItem(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = deleteVoucherForItem_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3087 
    if result.success is not None:
3088 
      return result.success
3089 
    if result.cex is not None:
3090 
      raise result.cex
3091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3092 
 
3093 
  def getVoucherAmount(self, itemId, voucherType):
3094 
    """
3095 
    Parameters:
3096 
     - itemId
3097 
     - voucherType
3098 
    """
3099 
    self.send_getVoucherAmount(itemId, voucherType)
3100 
    return self.recv_getVoucherAmount()
3101 
 
3102 
  def send_getVoucherAmount(self, itemId, voucherType):
3103 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3104 
    args = getVoucherAmount_args()
3105 
    args.itemId = itemId
3106 
    args.voucherType = voucherType
3107 
    args.write(self._oprot)
3108 
    self._oprot.writeMessageEnd()
3109 
    self._oprot.trans.flush()
3110 
 
3111 
  def recv_getVoucherAmount(self, ):
3112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3113 
    if mtype == TMessageType.EXCEPTION:
3114 
      x = TApplicationException()
3115 
      x.read(self._iprot)
3116 
      self._iprot.readMessageEnd()
3117 
      raise x
3118 
    result = getVoucherAmount_result()
3119 
    result.read(self._iprot)
3120 
    self._iprot.readMessageEnd()
3121 
    if result.success is not None:
3122 
      return result.success
3123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3124 
 
3125 
  def getAllItemVouchers(self, itemId):
3126 
    """
3127 
    Parameters:
3128 
     - itemId
3129 
    """
3130 
    self.send_getAllItemVouchers(itemId)
3131 
    return self.recv_getAllItemVouchers()
3132 
 
3133 
  def send_getAllItemVouchers(self, itemId):
3134 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3135 
    args = getAllItemVouchers_args()
3136 
    args.itemId = itemId
3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3141 
  def recv_getAllItemVouchers(self, ):
3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3148 
    result = getAllItemVouchers_result()
3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3151 
    if result.success is not None:
3152 
      return result.success
3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3154 
 
3155 
  def isValidCatalogItemId(self, catalog_item_id):
3156 
    """
3157 
    Parameters:
3158 
     - catalog_item_id
3159 
    """
3160 
    self.send_isValidCatalogItemId(catalog_item_id)
3161 
    return self.recv_isValidCatalogItemId()
3162 
 
3163 
  def send_isValidCatalogItemId(self, catalog_item_id):
3164 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3165 
    args = isValidCatalogItemId_args()
3166 
    args.catalog_item_id = catalog_item_id
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3171 
  def recv_isValidCatalogItemId(self, ):
3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3178 
    result = isValidCatalogItemId_result()
3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.success is not None:
3182 
      return result.success
3183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3184 
 
7330 amit.gupta 3185 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3186 
    """
3187 
    Parameters:
3188 
     - itemId
7330 amit.gupta 3189 
     - stateId
6039 amit.gupta 3190 
     - price
3191 
    """
7330 amit.gupta 3192 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3193 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3194 
 
7330 amit.gupta 3195 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3196 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3197 
    args = getVatPercentageForItem_args()
3198 
    args.itemId = itemId
7330 amit.gupta 3199 
    args.stateId = stateId
6039 amit.gupta 3200 
    args.price = price
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_getVatPercentageForItem(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = getVatPercentageForItem_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.success is not None:
3216 
      return result.success
7340 amit.gupta 3217 
    if result.cex is not None:
3218 
      raise result.cex
6039 amit.gupta 3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3220 
 
3221 
  def getVatAmountForItem(self, itemId, price):
3222 
    """
3223 
    Parameters:
3224 
     - itemId
3225 
     - price
3226 
    """
3227 
    self.send_getVatAmountForItem(itemId, price)
3228 
    return self.recv_getVatAmountForItem()
3229 
 
3230 
  def send_getVatAmountForItem(self, itemId, price):
3231 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3232 
    args = getVatAmountForItem_args()
3233 
    args.itemId = itemId
3234 
    args.price = price
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
3239 
  def recv_getVatAmountForItem(self, ):
3240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3241 
    if mtype == TMessageType.EXCEPTION:
3242 
      x = TApplicationException()
3243 
      x.read(self._iprot)
3244 
      self._iprot.readMessageEnd()
3245 
      raise x
3246 
    result = getVatAmountForItem_result()
3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
3249 
    if result.success is not None:
3250 
      return result.success
3251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3252 
 
6531 vikram.rag 3253 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3254 
    """
3255 
    Parameters:
3256 
     - offset
3257 
     - limit
3258 
    """
3259 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3260 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3261 
 
6531 vikram.rag 3262 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3263 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3264 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3265 
    args.offset = offset
3266 
    args.limit = limit
3267 
    args.write(self._oprot)
3268 
    self._oprot.writeMessageEnd()
3269 
    self._oprot.trans.flush()
3270 
 
3271 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3273 
    if mtype == TMessageType.EXCEPTION:
3274 
      x = TApplicationException()
3275 
      x.read(self._iprot)
3276 
      self._iprot.readMessageEnd()
3277 
      raise x
3278 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3279 
    result.read(self._iprot)
3280 
    self._iprot.readMessageEnd()
3281 
    if result.success is not None:
3282 
      return result.success
3283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3284 
 
6821 amar.kumar 3285 
  def getAllAliveItems(self, ):
3286 
    self.send_getAllAliveItems()
3287 
    return self.recv_getAllAliveItems()
3288 
 
3289 
  def send_getAllAliveItems(self, ):
3290 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3291 
    args = getAllAliveItems_args()
3292 
    args.write(self._oprot)
3293 
    self._oprot.writeMessageEnd()
3294 
    self._oprot.trans.flush()
3295 
 
3296 
  def recv_getAllAliveItems(self, ):
3297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3298 
    if mtype == TMessageType.EXCEPTION:
3299 
      x = TApplicationException()
3300 
      x.read(self._iprot)
3301 
      self._iprot.readMessageEnd()
3302 
      raise x
3303 
    result = getAllAliveItems_result()
3304 
    result.read(self._iprot)
3305 
    self._iprot.readMessageEnd()
3306 
    if result.success is not None:
3307 
      return result.success
3308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3309 
 
6921 anupam.sin 3310 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3311 
    """
3312 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3313 
 
6805 anupam.sin 3314 
    Parameters:
3315 
     - itemId
6921 anupam.sin 3316 
     - price
6805 anupam.sin 3317 
     - insurerId
3318 
     - quantity
3319 
    """
6921 anupam.sin 3320 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3321 
    return self.recv_getInsuranceAmount()
3322 
 
6921 anupam.sin 3323 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3324 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3325 
    args = getInsuranceAmount_args()
3326 
    args.itemId = itemId
6921 anupam.sin 3327 
    args.price = price
6805 anupam.sin 3328 
    args.insurerId = insurerId
3329 
    args.quantity = quantity
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_getInsuranceAmount(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = getInsuranceAmount_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3344 
    if result.success is not None:
3345 
      return result.success
3346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3347 
 
3348 
  def getInsurer(self, insurerId):
3349 
    """
3350 
    Parameters:
3351 
     - insurerId
3352 
    """
3353 
    self.send_getInsurer(insurerId)
3354 
    return self.recv_getInsurer()
3355 
 
3356 
  def send_getInsurer(self, insurerId):
3357 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3358 
    args = getInsurer_args()
3359 
    args.insurerId = insurerId
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_getInsurer(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = getInsurer_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3374 
    if result.success is not None:
3375 
      return result.success
3376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3377 
 
6838 vikram.rag 3378 
  def getAllInsurers(self, ):
3379 
    self.send_getAllInsurers()
3380 
    return self.recv_getAllInsurers()
6805 anupam.sin 3381 
 
6838 vikram.rag 3382 
  def send_getAllInsurers(self, ):
3383 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3384 
    args = getAllInsurers_args()
3385 
    args.write(self._oprot)
3386 
    self._oprot.writeMessageEnd()
3387 
    self._oprot.trans.flush()
3388 
 
3389 
  def recv_getAllInsurers(self, ):
3390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3391 
    if mtype == TMessageType.EXCEPTION:
3392 
      x = TApplicationException()
3393 
      x.read(self._iprot)
3394 
      self._iprot.readMessageEnd()
3395 
      raise x
3396 
    result = getAllInsurers_result()
3397 
    result.read(self._iprot)
3398 
    self._iprot.readMessageEnd()
3399 
    if result.success is not None:
3400 
      return result.success
3401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3402 
 
6962 rajveer 3403 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3404 
    """
3405 
    Parameters:
3406 
     - insurerId
3407 
     - amount
3408 
    """
3409 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3410 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3411 
 
6962 rajveer 3412 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3413 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3414 
    args = updateInsuranceDeclaredAmount_args()
3415 
    args.insurerId = insurerId
3416 
    args.amount = amount
3417 
    args.write(self._oprot)
3418 
    self._oprot.writeMessageEnd()
3419 
    self._oprot.trans.flush()
3420 
 
3421 
  def recv_updateInsuranceDeclaredAmount(self, ):
3422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3423 
    if mtype == TMessageType.EXCEPTION:
3424 
      x = TApplicationException()
3425 
      x.read(self._iprot)
3426 
      self._iprot.readMessageEnd()
3427 
      raise x
3428 
    result = updateInsuranceDeclaredAmount_result()
3429 
    result.read(self._iprot)
3430 
    self._iprot.readMessageEnd()
3431 
    return
3432 
 
7190 amar.kumar 3433 
  def getFreebieForItem(self, itemId):
3434 
    """
3435 
    Parameters:
3436 
     - itemId
3437 
    """
3438 
    self.send_getFreebieForItem(itemId)
3439 
    return self.recv_getFreebieForItem()
6962 rajveer 3440 
 
7190 amar.kumar 3441 
  def send_getFreebieForItem(self, itemId):
3442 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3443 
    args = getFreebieForItem_args()
3444 
    args.itemId = itemId
3445 
    args.write(self._oprot)
3446 
    self._oprot.writeMessageEnd()
3447 
    self._oprot.trans.flush()
3448 
 
3449 
  def recv_getFreebieForItem(self, ):
3450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3451 
    if mtype == TMessageType.EXCEPTION:
3452 
      x = TApplicationException()
3453 
      x.read(self._iprot)
3454 
      self._iprot.readMessageEnd()
3455 
      raise x
3456 
    result = getFreebieForItem_result()
3457 
    result.read(self._iprot)
3458 
    self._iprot.readMessageEnd()
3459 
    if result.success is not None:
3460 
      return result.success
3461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3462 
 
3463 
  def addOrUpdateFreebieForItem(self, freebieItem):
3464 
    """
3465 
    Parameters:
3466 
     - freebieItem
3467 
    """
3468 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3469 
    self.recv_addOrUpdateFreebieForItem()
3470 
 
3471 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3472 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3473 
    args = addOrUpdateFreebieForItem_args()
3474 
    args.freebieItem = freebieItem
3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_addOrUpdateFreebieForItem(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = addOrUpdateFreebieForItem_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3489 
    return
3490 
 
7272 amit.gupta 3491 
  def addOrUpdateBrandInfo(self, brandInfo):
3492 
    """
3493 
    Parameters:
3494 
     - brandInfo
3495 
    """
3496 
    self.send_addOrUpdateBrandInfo(brandInfo)
3497 
    self.recv_addOrUpdateBrandInfo()
3498 
 
3499 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3500 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3501 
    args = addOrUpdateBrandInfo_args()
3502 
    args.brandInfo = brandInfo
3503 
    args.write(self._oprot)
3504 
    self._oprot.writeMessageEnd()
3505 
    self._oprot.trans.flush()
3506 
 
3507 
  def recv_addOrUpdateBrandInfo(self, ):
3508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3509 
    if mtype == TMessageType.EXCEPTION:
3510 
      x = TApplicationException()
3511 
      x.read(self._iprot)
3512 
      self._iprot.readMessageEnd()
3513 
      raise x
3514 
    result = addOrUpdateBrandInfo_result()
3515 
    result.read(self._iprot)
3516 
    self._iprot.readMessageEnd()
3517 
    return
3518 
 
3519 
  def getBrandInfo(self, ):
3520 
    self.send_getBrandInfo()
3521 
    return self.recv_getBrandInfo()
3522 
 
3523 
  def send_getBrandInfo(self, ):
3524 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3525 
    args = getBrandInfo_args()
3526 
    args.write(self._oprot)
3527 
    self._oprot.writeMessageEnd()
3528 
    self._oprot.trans.flush()
3529 
 
3530 
  def recv_getBrandInfo(self, ):
3531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3532 
    if mtype == TMessageType.EXCEPTION:
3533 
      x = TApplicationException()
3534 
      x.read(self._iprot)
3535 
      self._iprot.readMessageEnd()
3536 
      raise x
3537 
    result = getBrandInfo_result()
3538 
    result.read(self._iprot)
3539 
    self._iprot.readMessageEnd()
3540 
    if result.success is not None:
3541 
      return result.success
3542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3543 
 
7256 rajveer 3544 
  def getStorePricing(self, itemId):
3545 
    """
3546 
    Parameters:
3547 
     - itemId
3548 
    """
3549 
    self.send_getStorePricing(itemId)
3550 
    return self.recv_getStorePricing()
7190 amar.kumar 3551 
 
7256 rajveer 3552 
  def send_getStorePricing(self, itemId):
3553 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3554 
    args = getStorePricing_args()
3555 
    args.itemId = itemId
3556 
    args.write(self._oprot)
3557 
    self._oprot.writeMessageEnd()
3558 
    self._oprot.trans.flush()
3559 
 
3560 
  def recv_getStorePricing(self, ):
3561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3562 
    if mtype == TMessageType.EXCEPTION:
3563 
      x = TApplicationException()
3564 
      x.read(self._iprot)
3565 
      self._iprot.readMessageEnd()
3566 
      raise x
3567 
    result = getStorePricing_result()
3568 
    result.read(self._iprot)
3569 
    self._iprot.readMessageEnd()
3570 
    if result.success is not None:
3571 
      return result.success
3572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3573 
 
7306 rajveer 3574 
  def getStorePricings(self, itemIds):
3575 
    """
3576 
    Parameters:
3577 
     - itemIds
3578 
    """
3579 
    self.send_getStorePricings(itemIds)
3580 
    return self.recv_getStorePricings()
3581 
 
3582 
  def send_getStorePricings(self, itemIds):
3583 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3584 
    args = getStorePricings_args()
3585 
    args.itemIds = itemIds
3586 
    args.write(self._oprot)
3587 
    self._oprot.writeMessageEnd()
3588 
    self._oprot.trans.flush()
3589 
 
3590 
  def recv_getStorePricings(self, ):
3591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3592 
    if mtype == TMessageType.EXCEPTION:
3593 
      x = TApplicationException()
3594 
      x.read(self._iprot)
3595 
      self._iprot.readMessageEnd()
3596 
      raise x
3597 
    result = getStorePricings_result()
3598 
    result.read(self._iprot)
3599 
    self._iprot.readMessageEnd()
3600 
    if result.success is not None:
3601 
      return result.success
3602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3603 
 
7382 rajveer 3604 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3605 
    """
3606 
    Parameters:
3607 
     - sp
7382 rajveer 3608 
     - allColors
7265 rajveer 3609 
    """
7382 rajveer 3610 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3611 
    self.recv_updateStorePricing()
7256 rajveer 3612 
 
7382 rajveer 3613 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3614 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3615 
    args = updateStorePricing_args()
3616 
    args.sp = sp
7382 rajveer 3617 
    args.allColors = allColors
7265 rajveer 3618 
    args.write(self._oprot)
3619 
    self._oprot.writeMessageEnd()
3620 
    self._oprot.trans.flush()
3621 
 
3622 
  def recv_updateStorePricing(self, ):
3623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3624 
    if mtype == TMessageType.EXCEPTION:
3625 
      x = TApplicationException()
3626 
      x.read(self._iprot)
3627 
      self._iprot.readMessageEnd()
3628 
      raise x
3629 
    result = updateStorePricing_result()
3630 
    result.read(self._iprot)
3631 
    self._iprot.readMessageEnd()
3632 
    return
3633 
 
7281 kshitij.so 3634 
  def getAllAmazonListedItems(self, ):
3635 
    self.send_getAllAmazonListedItems()
3636 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3637 
 
7281 kshitij.so 3638 
  def send_getAllAmazonListedItems(self, ):
3639 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3640 
    args = getAllAmazonListedItems_args()
3641 
    args.write(self._oprot)
3642 
    self._oprot.writeMessageEnd()
3643 
    self._oprot.trans.flush()
3644 
 
3645 
  def recv_getAllAmazonListedItems(self, ):
3646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3647 
    if mtype == TMessageType.EXCEPTION:
3648 
      x = TApplicationException()
3649 
      x.read(self._iprot)
3650 
      self._iprot.readMessageEnd()
3651 
      raise x
3652 
    result = getAllAmazonListedItems_result()
3653 
    result.read(self._iprot)
3654 
    self._iprot.readMessageEnd()
3655 
    if result.success is not None:
3656 
      return result.success
3657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3658 
 
3659 
  def getAmazonItemDetails(self, itemId):
3660 
    """
3661 
    Parameters:
3662 
     - itemId
3663 
    """
3664 
    self.send_getAmazonItemDetails(itemId)
3665 
    return self.recv_getAmazonItemDetails()
3666 
 
3667 
  def send_getAmazonItemDetails(self, itemId):
3668 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3669 
    args = getAmazonItemDetails_args()
3670 
    args.itemId = itemId
3671 
    args.write(self._oprot)
3672 
    self._oprot.writeMessageEnd()
3673 
    self._oprot.trans.flush()
3674 
 
3675 
  def recv_getAmazonItemDetails(self, ):
3676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3677 
    if mtype == TMessageType.EXCEPTION:
3678 
      x = TApplicationException()
3679 
      x.read(self._iprot)
3680 
      self._iprot.readMessageEnd()
3681 
      raise x
3682 
    result = getAmazonItemDetails_result()
3683 
    result.read(self._iprot)
3684 
    self._iprot.readMessageEnd()
3685 
    if result.success is not None:
3686 
      return result.success
3687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3688 
 
7367 kshitij.so 3689 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3690 
    """
3691 
    Parameters:
3692 
     - itemId
3693 
     - fbaPrice
3694 
     - sellingPrice
3695 
     - isFba
3696 
     - isNonFba
3697 
     - isInventoryOverride
7367 kshitij.so 3698 
     - handlingTime
3699 
     - isCustomTime
7281 kshitij.so 3700 
    """
7367 kshitij.so 3701 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3702 
    self.recv_updateAmazonItemDetails()
3703 
 
7367 kshitij.so 3704 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3705 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3706 
    args = updateAmazonItemDetails_args()
3707 
    args.itemId = itemId
3708 
    args.fbaPrice = fbaPrice
3709 
    args.sellingPrice = sellingPrice
3710 
    args.isFba = isFba
3711 
    args.isNonFba = isNonFba
3712 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3713 
    args.handlingTime = handlingTime
3714 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3715 
    args.write(self._oprot)
3716 
    self._oprot.writeMessageEnd()
3717 
    self._oprot.trans.flush()
3718 
 
3719 
  def recv_updateAmazonItemDetails(self, ):
3720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3721 
    if mtype == TMessageType.EXCEPTION:
3722 
      x = TApplicationException()
3723 
      x.read(self._iprot)
3724 
      self._iprot.readMessageEnd()
3725 
      raise x
3726 
    result = updateAmazonItemDetails_result()
3727 
    result.read(self._iprot)
3728 
    self._iprot.readMessageEnd()
3729 
    return
3730 
 
3731 
  def addAmazonItem(self, amazonlisted):
3732 
    """
3733 
    Parameters:
3734 
     - amazonlisted
3735 
    """
3736 
    self.send_addAmazonItem(amazonlisted)
3737 
    self.recv_addAmazonItem()
3738 
 
3739 
  def send_addAmazonItem(self, amazonlisted):
3740 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3741 
    args = addAmazonItem_args()
3742 
    args.amazonlisted = amazonlisted
3743 
    args.write(self._oprot)
3744 
    self._oprot.writeMessageEnd()
3745 
    self._oprot.trans.flush()
3746 
 
3747 
  def recv_addAmazonItem(self, ):
3748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3749 
    if mtype == TMessageType.EXCEPTION:
3750 
      x = TApplicationException()
3751 
      x.read(self._iprot)
3752 
      self._iprot.readMessageEnd()
3753 
      raise x
3754 
    result = addAmazonItem_result()
3755 
    result.read(self._iprot)
3756 
    self._iprot.readMessageEnd()
3757 
    return
3758 
 
7291 vikram.rag 3759 
  def getAsinItems(self, ):
3760 
    self.send_getAsinItems()
3761 
    return self.recv_getAsinItems()
7281 kshitij.so 3762 
 
7291 vikram.rag 3763 
  def send_getAsinItems(self, ):
3764 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3765 
    args = getAsinItems_args()
3766 
    args.write(self._oprot)
3767 
    self._oprot.writeMessageEnd()
3768 
    self._oprot.trans.flush()
3769 
 
3770 
  def recv_getAsinItems(self, ):
3771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3772 
    if mtype == TMessageType.EXCEPTION:
3773 
      x = TApplicationException()
3774 
      x.read(self._iprot)
3775 
      self._iprot.readMessageEnd()
3776 
      raise x
3777 
    result = getAsinItems_result()
3778 
    result.read(self._iprot)
3779 
    self._iprot.readMessageEnd()
3780 
    if result.success is not None:
3781 
      return result.success
3782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3783 
 
3784 
  def getAllFbaListedItems(self, ):
3785 
    self.send_getAllFbaListedItems()
3786 
    return self.recv_getAllFbaListedItems()
3787 
 
3788 
  def send_getAllFbaListedItems(self, ):
3789 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3790 
    args = getAllFbaListedItems_args()
3791 
    args.write(self._oprot)
3792 
    self._oprot.writeMessageEnd()
3793 
    self._oprot.trans.flush()
3794 
 
3795 
  def recv_getAllFbaListedItems(self, ):
3796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3797 
    if mtype == TMessageType.EXCEPTION:
3798 
      x = TApplicationException()
3799 
      x.read(self._iprot)
3800 
      self._iprot.readMessageEnd()
3801 
      raise x
3802 
    result = getAllFbaListedItems_result()
3803 
    result.read(self._iprot)
3804 
    self._iprot.readMessageEnd()
3805 
    if result.success is not None:
3806 
      return result.success
3807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3808 
 
3809 
  def getAllNonFbaListedItems(self, ):
3810 
    self.send_getAllNonFbaListedItems()
3811 
    return self.recv_getAllNonFbaListedItems()
3812 
 
3813 
  def send_getAllNonFbaListedItems(self, ):
3814 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3815 
    args = getAllNonFbaListedItems_args()
3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_getAllNonFbaListedItems(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = getAllNonFbaListedItems_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
3830 
    if result.success is not None:
3831 
      return result.success
3832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3833 
 
7460 kshitij.so 3834 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3835 
    """
3836 
    Parameters:
3837 
     - itemId
3838 
     - holdInventory
3839 
     - defaultInventory
3840 
    """
3841 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3842 
    return self.recv_updateItemInventory()
7291 vikram.rag 3843 
 
7460 kshitij.so 3844 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3845 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3846 
    args = updateItemInventory_args()
3847 
    args.itemId = itemId
3848 
    args.holdInventory = holdInventory
3849 
    args.defaultInventory = defaultInventory
3850 
    args.write(self._oprot)
3851 
    self._oprot.writeMessageEnd()
3852 
    self._oprot.trans.flush()
3853 
 
3854 
  def recv_updateItemInventory(self, ):
3855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3856 
    if mtype == TMessageType.EXCEPTION:
3857 
      x = TApplicationException()
3858 
      x.read(self._iprot)
3859 
      self._iprot.readMessageEnd()
3860 
      raise x
3861 
    result = updateItemInventory_result()
3862 
    result.read(self._iprot)
3863 
    self._iprot.readMessageEnd()
3864 
    if result.success is not None:
3865 
      return result.success
3866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3867 
 
7770 kshitij.so 3868 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3869 
    """
3870 
    Parameters:
3871 
     - type
3872 
     - sku
3873 
     - timestamp
3874 
    """
3875 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3876 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3877 
 
7770 kshitij.so 3878 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3879 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3880 
    args = updateTimestampForAmazonFeeds_args()
3881 
    args.type = type
3882 
    args.sku = sku
3883 
    args.timestamp = timestamp
3884 
    args.write(self._oprot)
3885 
    self._oprot.writeMessageEnd()
3886 
    self._oprot.trans.flush()
3887 
 
3888 
  def recv_updateTimestampForAmazonFeeds(self, ):
3889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3890 
    if mtype == TMessageType.EXCEPTION:
3891 
      x = TApplicationException()
3892 
      x.read(self._iprot)
3893 
      self._iprot.readMessageEnd()
3894 
      raise x
3895 
    result = updateTimestampForAmazonFeeds_result()
3896 
    result.read(self._iprot)
3897 
    self._iprot.readMessageEnd()
3898 
    if result.success is not None:
3899 
      return result.success
3900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3901 
 
7897 amar.kumar 3902 
  def getAllParentCategories(self, ):
3903 
    self.send_getAllParentCategories()
3904 
    return self.recv_getAllParentCategories()
7770 kshitij.so 3905 
 
7897 amar.kumar 3906 
  def send_getAllParentCategories(self, ):
3907 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
3908 
    args = getAllParentCategories_args()
3909 
    args.write(self._oprot)
3910 
    self._oprot.writeMessageEnd()
3911 
    self._oprot.trans.flush()
3912 
 
3913 
  def recv_getAllParentCategories(self, ):
3914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3915 
    if mtype == TMessageType.EXCEPTION:
3916 
      x = TApplicationException()
3917 
      x.read(self._iprot)
3918 
      self._iprot.readMessageEnd()
3919 
      raise x
3920 
    result = getAllParentCategories_result()
3921 
    result.read(self._iprot)
3922 
    self._iprot.readMessageEnd()
3923 
    if result.success is not None:
3924 
      return result.success
3925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
3926 
 
3927 
 
5944 mandeep.dh 3928 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3929 
  def __init__(self, handler):
3930 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3931 
    self._processMap["addItem"] = Processor.process_addItem
3932 
    self._processMap["updateItem"] = Processor.process_updateItem
3933 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 3934 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 3935 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3936 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3937 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3938 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3939 
    self._processMap["getItem"] = Processor.process_getItem
3940 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3941 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3942 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3943 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3944 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3945 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3946 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3947 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3948 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3949 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3950 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3951 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3952 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3953 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3954 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3955 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3956 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3957 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3958 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3959 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3960 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3961 
    self._processMap["addCategory"] = Processor.process_addCategory
3962 
    self._processMap["getCategory"] = Processor.process_getCategory
3963 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3964 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3965 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3966 
    self._processMap["addTag"] = Processor.process_addTag
3967 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3968 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3969 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3970 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3971 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3972 
    self._processMap["addBanner"] = Processor.process_addBanner
3973 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3974 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3975 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3976 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3977 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3978 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3979 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3980 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3981 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3982 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3983 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3984 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3985 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3986 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3987 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3988 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3989 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3990 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3991 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3992 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3993 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3994 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3995 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3996 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3997 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3998 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3999 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4000 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4001 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4002 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4003 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4004 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4005 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4006 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4007 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4008 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4009 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4010 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4011 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4012 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4013 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4014 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4015 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4016 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4017 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4018 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4019 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4020 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4021 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4022 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4023 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4024 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4025 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4026 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4027 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4028 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4029 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4030 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
5944 mandeep.dh 4031 
 
4032 
  def process(self, iprot, oprot):
4033 
    (name, type, seqid) = iprot.readMessageBegin()
4034 
    if name not in self._processMap:
4035 
      iprot.skip(TType.STRUCT)
4036 
      iprot.readMessageEnd()
4037 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4038 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4039 
      x.write(oprot)
4040 
      oprot.writeMessageEnd()
4041 
      oprot.trans.flush()
4042 
      return
4043 
    else:
4044 
      self._processMap[name](self, seqid, iprot, oprot)
4045 
    return True
4046 
 
4047 
  def process_addItem(self, seqid, iprot, oprot):
4048 
    args = addItem_args()
4049 
    args.read(iprot)
4050 
    iprot.readMessageEnd()
4051 
    result = addItem_result()
4052 
    try:
4053 
      result.success = self._handler.addItem(args.item)
4054 
    except CatalogServiceException, cex:
4055 
      result.cex = cex
4056 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4057 
    result.write(oprot)
4058 
    oprot.writeMessageEnd()
4059 
    oprot.trans.flush()
4060 
 
4061 
  def process_updateItem(self, seqid, iprot, oprot):
4062 
    args = updateItem_args()
4063 
    args.read(iprot)
4064 
    iprot.readMessageEnd()
4065 
    result = updateItem_result()
4066 
    try:
4067 
      result.success = self._handler.updateItem(args.item)
4068 
    except CatalogServiceException, cex:
4069 
      result.cex = cex
4070 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4071 
    result.write(oprot)
4072 
    oprot.writeMessageEnd()
4073 
    oprot.trans.flush()
4074 
 
4075 
  def process_isActive(self, seqid, iprot, oprot):
4076 
    args = isActive_args()
4077 
    args.read(iprot)
4078 
    iprot.readMessageEnd()
4079 
    result = isActive_result()
4080 
    try:
4081 
      result.success = self._handler.isActive(args.itemId)
4082 
    except CatalogServiceException, isex:
4083 
      result.isex = isex
4084 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4088 
 
7438 amit.gupta 4089 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4090 
    args = getItemsStatus_args()
4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
4093 
    result = getItemsStatus_result()
4094 
    try:
4095 
      result.success = self._handler.getItemsStatus(args.itemIds)
4096 
    except CatalogServiceException, isex:
4097 
      result.isex = isex
4098 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4099 
    result.write(oprot)
4100 
    oprot.writeMessageEnd()
4101 
    oprot.trans.flush()
4102 
 
5944 mandeep.dh 4103 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4104 
    args = getItemStatusDescription_args()
4105 
    args.read(iprot)
4106 
    iprot.readMessageEnd()
4107 
    result = getItemStatusDescription_result()
4108 
    try:
4109 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4110 
    except CatalogServiceException, isex:
4111 
      result.isex = isex
4112 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4113 
    result.write(oprot)
4114 
    oprot.writeMessageEnd()
4115 
    oprot.trans.flush()
4116 
 
4117 
  def process_startItemOn(self, seqid, iprot, oprot):
4118 
    args = startItemOn_args()
4119 
    args.read(iprot)
4120 
    iprot.readMessageEnd()
4121 
    result = startItemOn_result()
4122 
    try:
4123 
      self._handler.startItemOn(args.item_id, args.timestamp)
4124 
    except CatalogServiceException, cex:
4125 
      result.cex = cex
4126 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4127 
    result.write(oprot)
4128 
    oprot.writeMessageEnd()
4129 
    oprot.trans.flush()
4130 
 
4131 
  def process_retireItemOn(self, seqid, iprot, oprot):
4132 
    args = retireItemOn_args()
4133 
    args.read(iprot)
4134 
    iprot.readMessageEnd()
4135 
    result = retireItemOn_result()
4136 
    try:
4137 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4138 
    except CatalogServiceException, cex:
4139 
      result.cex = cex
4140 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4141 
    result.write(oprot)
4142 
    oprot.writeMessageEnd()
4143 
    oprot.trans.flush()
4144 
 
4145 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4146 
    args = changeItemStatus_args()
4147 
    args.read(iprot)
4148 
    iprot.readMessageEnd()
4149 
    result = changeItemStatus_result()
4150 
    try:
4151 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4152 
    except CatalogServiceException, cex:
4153 
      result.cex = cex
4154 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4155 
    result.write(oprot)
4156 
    oprot.writeMessageEnd()
4157 
    oprot.trans.flush()
4158 
 
4159 
  def process_getItem(self, seqid, iprot, oprot):
4160 
    args = getItem_args()
4161 
    args.read(iprot)
4162 
    iprot.readMessageEnd()
4163 
    result = getItem_result()
4164 
    try:
4165 
      result.success = self._handler.getItem(args.item_id)
4166 
    except CatalogServiceException, cex:
4167 
      result.cex = cex
4168 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4169 
    result.write(oprot)
4170 
    oprot.writeMessageEnd()
4171 
    oprot.trans.flush()
4172 
 
4173 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4174 
    args = getItemsByCatalogId_args()
4175 
    args.read(iprot)
4176 
    iprot.readMessageEnd()
4177 
    result = getItemsByCatalogId_result()
4178 
    try:
4179 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4180 
    except CatalogServiceException, cex:
4181 
      result.cex = cex
4182 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4183 
    result.write(oprot)
4184 
    oprot.writeMessageEnd()
4185 
    oprot.trans.flush()
4186 
 
4187 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4188 
    args = getValidItemsByCatalogId_args()
4189 
    args.read(iprot)
4190 
    iprot.readMessageEnd()
4191 
    result = getValidItemsByCatalogId_result()
4192 
    try:
4193 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4194 
    except CatalogServiceException, cex:
4195 
      result.cex = cex
4196 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4197 
    result.write(oprot)
4198 
    oprot.writeMessageEnd()
4199 
    oprot.trans.flush()
4200 
 
4201 
  def process_getAllItems(self, seqid, iprot, oprot):
4202 
    args = getAllItems_args()
4203 
    args.read(iprot)
4204 
    iprot.readMessageEnd()
4205 
    result = getAllItems_result()
4206 
    try:
4207 
      result.success = self._handler.getAllItems(args.isActive)
4208 
    except CatalogServiceException, cex:
4209 
      result.cex = cex
4210 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4211 
    result.write(oprot)
4212 
    oprot.writeMessageEnd()
4213 
    oprot.trans.flush()
4214 
 
4215 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4216 
    args = getAllItemsByStatus_args()
4217 
    args.read(iprot)
4218 
    iprot.readMessageEnd()
4219 
    result = getAllItemsByStatus_result()
4220 
    try:
4221 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4222 
    except CatalogServiceException, cex:
4223 
      result.cex = cex
4224 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4225 
    result.write(oprot)
4226 
    oprot.writeMessageEnd()
4227 
    oprot.trans.flush()
4228 
 
4229 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4230 
    args = markItemAsContentComplete_args()
4231 
    args.read(iprot)
4232 
    iprot.readMessageEnd()
4233 
    result = markItemAsContentComplete_result()
4234 
    try:
4235 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4236 
    except CatalogServiceException, cex:
4237 
      result.cex = cex
4238 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4239 
    result.write(oprot)
4240 
    oprot.writeMessageEnd()
4241 
    oprot.trans.flush()
4242 
 
4243 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4244 
    args = getAllItemsInRange_args()
4245 
    args.read(iprot)
4246 
    iprot.readMessageEnd()
4247 
    result = getAllItemsInRange_result()
4248 
    try:
4249 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4250 
    except CatalogServiceException, cex:
4251 
      result.cex = cex
4252 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4253 
    result.write(oprot)
4254 
    oprot.writeMessageEnd()
4255 
    oprot.trans.flush()
4256 
 
4257 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4258 
    args = getAllItemsByStatusInRange_args()
4259 
    args.read(iprot)
4260 
    iprot.readMessageEnd()
4261 
    result = getAllItemsByStatusInRange_result()
4262 
    try:
4263 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4264 
    except CatalogServiceException, cex:
4265 
      result.cex = cex
4266 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4267 
    result.write(oprot)
4268 
    oprot.writeMessageEnd()
4269 
    oprot.trans.flush()
4270 
 
4271 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4272 
    args = getItemCountByStatus_args()
4273 
    args.read(iprot)
4274 
    iprot.readMessageEnd()
4275 
    result = getItemCountByStatus_result()
4276 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4277 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4278 
    result.write(oprot)
4279 
    oprot.writeMessageEnd()
4280 
    oprot.trans.flush()
4281 
 
4282 
  def process_getBestSellers(self, seqid, iprot, oprot):
4283 
    args = getBestSellers_args()
4284 
    args.read(iprot)
4285 
    iprot.readMessageEnd()
4286 
    result = getBestSellers_result()
4287 
    try:
4288 
      result.success = self._handler.getBestSellers()
4289 
    except CatalogServiceException, isex:
4290 
      result.isex = isex
4291 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4292 
    result.write(oprot)
4293 
    oprot.writeMessageEnd()
4294 
    oprot.trans.flush()
4295 
 
4296 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4297 
    args = getBestSellersCatalogIds_args()
4298 
    args.read(iprot)
4299 
    iprot.readMessageEnd()
4300 
    result = getBestSellersCatalogIds_result()
4301 
    try:
4302 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4303 
    except CatalogServiceException, cex:
4304 
      result.cex = cex
4305 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4306 
    result.write(oprot)
4307 
    oprot.writeMessageEnd()
4308 
    oprot.trans.flush()
4309 
 
4310 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4311 
    args = getBestSellersCount_args()
4312 
    args.read(iprot)
4313 
    iprot.readMessageEnd()
4314 
    result = getBestSellersCount_result()
4315 
    try:
4316 
      result.success = self._handler.getBestSellersCount()
4317 
    except CatalogServiceException, cex:
4318 
      result.cex = cex
4319 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4320 
    result.write(oprot)
4321 
    oprot.writeMessageEnd()
4322 
    oprot.trans.flush()
4323 
 
4324 
  def process_getBestDeals(self, seqid, iprot, oprot):
4325 
    args = getBestDeals_args()
4326 
    args.read(iprot)
4327 
    iprot.readMessageEnd()
4328 
    result = getBestDeals_result()
4329 
    try:
4330 
      result.success = self._handler.getBestDeals()
4331 
    except CatalogServiceException, isex:
4332 
      result.isex = isex
4333 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4334 
    result.write(oprot)
4335 
    oprot.writeMessageEnd()
4336 
    oprot.trans.flush()
4337 
 
4338 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4339 
    args = getBestDealsCatalogIds_args()
4340 
    args.read(iprot)
4341 
    iprot.readMessageEnd()
4342 
    result = getBestDealsCatalogIds_result()
4343 
    try:
4344 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4345 
    except CatalogServiceException, cex:
4346 
      result.cex = cex
4347 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4348 
    result.write(oprot)
4349 
    oprot.writeMessageEnd()
4350 
    oprot.trans.flush()
4351 
 
4352 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4353 
    args = getBestDealsCount_args()
4354 
    args.read(iprot)
4355 
    iprot.readMessageEnd()
4356 
    result = getBestDealsCount_result()
4357 
    try:
4358 
      result.success = self._handler.getBestDealsCount()
4359 
    except CatalogServiceException, cex:
4360 
      result.cex = cex
4361 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4362 
    result.write(oprot)
4363 
    oprot.writeMessageEnd()
4364 
    oprot.trans.flush()
4365 
 
4366 
  def process_getComingSoon(self, seqid, iprot, oprot):
4367 
    args = getComingSoon_args()
4368 
    args.read(iprot)
4369 
    iprot.readMessageEnd()
4370 
    result = getComingSoon_result()
4371 
    try:
4372 
      result.success = self._handler.getComingSoon()
4373 
    except CatalogServiceException, isex:
4374 
      result.isex = isex
4375 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4376 
    result.write(oprot)
4377 
    oprot.writeMessageEnd()
4378 
    oprot.trans.flush()
4379 
 
4380 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4381 
    args = getComingSoonCatalogIds_args()
4382 
    args.read(iprot)
4383 
    iprot.readMessageEnd()
4384 
    result = getComingSoonCatalogIds_result()
4385 
    try:
4386 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4387 
    except CatalogServiceException, cex:
4388 
      result.cex = cex
4389 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4390 
    result.write(oprot)
4391 
    oprot.writeMessageEnd()
4392 
    oprot.trans.flush()
4393 
 
4394 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4395 
    args = getComingSoonCount_args()
4396 
    args.read(iprot)
4397 
    iprot.readMessageEnd()
4398 
    result = getComingSoonCount_result()
4399 
    try:
4400 
      result.success = self._handler.getComingSoonCount()
4401 
    except CatalogServiceException, cex:
4402 
      result.cex = cex
4403 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4404 
    result.write(oprot)
4405 
    oprot.writeMessageEnd()
4406 
    oprot.trans.flush()
4407 
 
4408 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4409 
    args = getLatestArrivals_args()
4410 
    args.read(iprot)
4411 
    iprot.readMessageEnd()
4412 
    result = getLatestArrivals_result()
4413 
    try:
4414 
      result.success = self._handler.getLatestArrivals()
4415 
    except CatalogServiceException, isex:
4416 
      result.isex = isex
4417 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4418 
    result.write(oprot)
4419 
    oprot.writeMessageEnd()
4420 
    oprot.trans.flush()
4421 
 
4422 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4423 
    args = getLatestArrivalsCatalogIds_args()
4424 
    args.read(iprot)
4425 
    iprot.readMessageEnd()
4426 
    result = getLatestArrivalsCatalogIds_result()
4427 
    try:
4428 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4429 
    except CatalogServiceException, cex:
4430 
      result.cex = cex
4431 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4432 
    result.write(oprot)
4433 
    oprot.writeMessageEnd()
4434 
    oprot.trans.flush()
4435 
 
4436 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4437 
    args = getLatestArrivalsCount_args()
4438 
    args.read(iprot)
4439 
    iprot.readMessageEnd()
4440 
    result = getLatestArrivalsCount_result()
4441 
    try:
4442 
      result.success = self._handler.getLatestArrivalsCount()
4443 
    except CatalogServiceException, cex:
4444 
      result.cex = cex
4445 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4446 
    result.write(oprot)
4447 
    oprot.writeMessageEnd()
4448 
    oprot.trans.flush()
4449 
 
4450 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4451 
    args = generateNewEntityID_args()
4452 
    args.read(iprot)
4453 
    iprot.readMessageEnd()
4454 
    result = generateNewEntityID_result()
4455 
    result.success = self._handler.generateNewEntityID()
4456 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4460 
 
4461 
  def process_addCategory(self, seqid, iprot, oprot):
4462 
    args = addCategory_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = addCategory_result()
4466 
    result.success = self._handler.addCategory(args.category)
4467 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4468 
    result.write(oprot)
4469 
    oprot.writeMessageEnd()
4470 
    oprot.trans.flush()
4471 
 
4472 
  def process_getCategory(self, seqid, iprot, oprot):
4473 
    args = getCategory_args()
4474 
    args.read(iprot)
4475 
    iprot.readMessageEnd()
4476 
    result = getCategory_result()
4477 
    result.success = self._handler.getCategory(args.id)
4478 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4479 
    result.write(oprot)
4480 
    oprot.writeMessageEnd()
4481 
    oprot.trans.flush()
4482 
 
4483 
  def process_getAllCategories(self, seqid, iprot, oprot):
4484 
    args = getAllCategories_args()
4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
4487 
    result = getAllCategories_result()
4488 
    result.success = self._handler.getAllCategories()
4489 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4490 
    result.write(oprot)
4491 
    oprot.writeMessageEnd()
4492 
    oprot.trans.flush()
4493 
 
4494 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4495 
    args = getAllSimilarItems_args()
4496 
    args.read(iprot)
4497 
    iprot.readMessageEnd()
4498 
    result = getAllSimilarItems_result()
4499 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4500 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
4505 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4506 
    args = addSimilarItem_args()
4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
4509 
    result = addSimilarItem_result()
4510 
    try:
4511 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4512 
    except CatalogServiceException, cex:
4513 
      result.cex = cex
4514 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4515 
    result.write(oprot)
4516 
    oprot.writeMessageEnd()
4517 
    oprot.trans.flush()
4518 
 
6512 kshitij.so 4519 
  def process_addTag(self, seqid, iprot, oprot):
4520 
    args = addTag_args()
4521 
    args.read(iprot)
4522 
    iprot.readMessageEnd()
4523 
    result = addTag_result()
4524 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4525 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4526 
    result.write(oprot)
4527 
    oprot.writeMessageEnd()
4528 
    oprot.trans.flush()
4529 
 
4530 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4531 
    args = deleteEntityTag_args()
4532 
    args.read(iprot)
4533 
    iprot.readMessageEnd()
4534 
    result = deleteEntityTag_result()
4535 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4536 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
4540 
 
4541 
  def process_deleteTag(self, seqid, iprot, oprot):
4542 
    args = deleteTag_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = deleteTag_result()
4546 
    result.success = self._handler.deleteTag(args.displayName)
4547 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
4551 
 
4552 
  def process_getAllTags(self, seqid, iprot, oprot):
4553 
    args = getAllTags_args()
4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
4556 
    result = getAllTags_result()
4557 
    result.success = self._handler.getAllTags()
4558 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4559 
    result.write(oprot)
4560 
    oprot.writeMessageEnd()
4561 
    oprot.trans.flush()
4562 
 
4563 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4564 
    args = getAllEntitiesByTagName_args()
4565 
    args.read(iprot)
4566 
    iprot.readMessageEnd()
4567 
    result = getAllEntitiesByTagName_result()
4568 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4569 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4570 
    result.write(oprot)
4571 
    oprot.writeMessageEnd()
4572 
    oprot.trans.flush()
4573 
 
6845 amit.gupta 4574 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4575 
    args = getAllEntityTags_args()
4576 
    args.read(iprot)
4577 
    iprot.readMessageEnd()
4578 
    result = getAllEntityTags_result()
4579 
    result.success = self._handler.getAllEntityTags()
4580 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
4584 
 
6850 kshitij.so 4585 
  def process_addBanner(self, seqid, iprot, oprot):
4586 
    args = addBanner_args()
4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
4589 
    result = addBanner_result()
4590 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4591 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4592 
    result.write(oprot)
4593 
    oprot.writeMessageEnd()
4594 
    oprot.trans.flush()
4595 
 
4596 
  def process_getAllBanners(self, seqid, iprot, oprot):
4597 
    args = getAllBanners_args()
4598 
    args.read(iprot)
4599 
    iprot.readMessageEnd()
4600 
    result = getAllBanners_result()
4601 
    result.success = self._handler.getAllBanners()
4602 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4603 
    result.write(oprot)
4604 
    oprot.writeMessageEnd()
4605 
    oprot.trans.flush()
4606 
 
4607 
  def process_deleteBanner(self, seqid, iprot, oprot):
4608 
    args = deleteBanner_args()
4609 
    args.read(iprot)
4610 
    iprot.readMessageEnd()
4611 
    result = deleteBanner_result()
4612 
    result.success = self._handler.deleteBanner(args.bannerName)
4613 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4614 
    result.write(oprot)
4615 
    oprot.writeMessageEnd()
4616 
    oprot.trans.flush()
4617 
 
4618 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4619 
    args = getBannerDetails_args()
4620 
    args.read(iprot)
4621 
    iprot.readMessageEnd()
4622 
    result = getBannerDetails_result()
4623 
    result.success = self._handler.getBannerDetails(args.bannerName)
4624 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4625 
    result.write(oprot)
4626 
    oprot.writeMessageEnd()
4627 
    oprot.trans.flush()
4628 
 
4629 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4630 
    args = getActiveBanners_args()
4631 
    args.read(iprot)
4632 
    iprot.readMessageEnd()
4633 
    result = getActiveBanners_result()
4634 
    result.success = self._handler.getActiveBanners()
4635 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4636 
    result.write(oprot)
4637 
    oprot.writeMessageEnd()
4638 
    oprot.trans.flush()
4639 
 
6849 kshitij.so 4640 
  def process_addBannerMap(self, seqid, iprot, oprot):
4641 
    args = addBannerMap_args()
4642 
    args.read(iprot)
4643 
    iprot.readMessageEnd()
4644 
    result = addBannerMap_result()
4645 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4646 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4647 
    result.write(oprot)
4648 
    oprot.writeMessageEnd()
4649 
    oprot.trans.flush()
4650 
 
4651 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4652 
    args = deleteBannerMap_args()
4653 
    args.read(iprot)
4654 
    iprot.readMessageEnd()
4655 
    result = deleteBannerMap_result()
4656 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4657 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4658 
    result.write(oprot)
4659 
    oprot.writeMessageEnd()
4660 
    oprot.trans.flush()
4661 
 
4662 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4663 
    args = getBannerMapDetails_args()
4664 
    args.read(iprot)
4665 
    iprot.readMessageEnd()
4666 
    result = getBannerMapDetails_result()
4667 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4668 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4669 
    result.write(oprot)
4670 
    oprot.writeMessageEnd()
4671 
    oprot.trans.flush()
4672 
 
5944 mandeep.dh 4673 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4674 
    args = deleteSimilarItem_args()
4675 
    args.read(iprot)
4676 
    iprot.readMessageEnd()
4677 
    result = deleteSimilarItem_result()
4678 
    try:
4679 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4680 
    except CatalogServiceException, cex:
4681 
      result.cex = cex
4682 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
4687 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4688 
    args = checkSimilarItem_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = checkSimilarItem_result()
4692 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4693 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
4698 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4699 
    args = validateRiskyStatus_args()
4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4702 
    result = validateRiskyStatus_result()
4703 
    self._handler.validateRiskyStatus(args.itemId)
4704 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
4709 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4710 
    args = changeItemRiskyFlag_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = changeItemRiskyFlag_result()
4714 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4715 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4720 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4721 
    args = getItemsByRiskyFlag_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getItemsByRiskyFlag_result()
4725 
    result.success = self._handler.getItemsByRiskyFlag()
4726 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
4730 
 
4731 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4732 
    args = getItemsForMasterSheet_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = getItemsForMasterSheet_result()
4736 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4737 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4741 
 
4742 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4743 
    args = getSimilarItemsCatalogIds_args()
4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
4746 
    result = getSimilarItemsCatalogIds_result()
4747 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4748 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
4753 
  def process_addProductNotification(self, seqid, iprot, oprot):
4754 
    args = addProductNotification_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = addProductNotification_result()
4758 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4759 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4763 
 
4764 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4765 
    args = sendProductNotifications_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = sendProductNotifications_result()
4769 
    result.success = self._handler.sendProductNotifications()
4770 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4771 
    result.write(oprot)
4772 
    oprot.writeMessageEnd()
4773 
    oprot.trans.flush()
4774 
 
4775 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4776 
    args = getAllBrandsByCategory_args()
4777 
    args.read(iprot)
4778 
    iprot.readMessageEnd()
4779 
    result = getAllBrandsByCategory_result()
4780 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4781 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4782 
    result.write(oprot)
4783 
    oprot.writeMessageEnd()
4784 
    oprot.trans.flush()
4785 
 
4786 
  def process_getAllBrands(self, seqid, iprot, oprot):
4787 
    args = getAllBrands_args()
4788 
    args.read(iprot)
4789 
    iprot.readMessageEnd()
4790 
    result = getAllBrands_result()
4791 
    result.success = self._handler.getAllBrands()
4792 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4793 
    result.write(oprot)
4794 
    oprot.writeMessageEnd()
4795 
    oprot.trans.flush()
4796 
 
4797 
  def process_getAllSources(self, seqid, iprot, oprot):
4798 
    args = getAllSources_args()
4799 
    args.read(iprot)
4800 
    iprot.readMessageEnd()
4801 
    result = getAllSources_result()
4802 
    result.success = self._handler.getAllSources()
4803 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4804 
    result.write(oprot)
4805 
    oprot.writeMessageEnd()
4806 
    oprot.trans.flush()
4807 
 
4808 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4809 
    args = getItemPricingBySource_args()
4810 
    args.read(iprot)
4811 
    iprot.readMessageEnd()
4812 
    result = getItemPricingBySource_result()
4813 
    try:
4814 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4815 
    except CatalogServiceException, cex:
4816 
      result.cex = cex
4817 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4818 
    result.write(oprot)
4819 
    oprot.writeMessageEnd()
4820 
    oprot.trans.flush()
4821 
 
4822 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4823 
    args = addSourceItemPricing_args()
4824 
    args.read(iprot)
4825 
    iprot.readMessageEnd()
4826 
    result = addSourceItemPricing_result()
4827 
    try:
4828 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4829 
    except CatalogServiceException, cex:
4830 
      result.cex = cex
4831 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4832 
    result.write(oprot)
4833 
    oprot.writeMessageEnd()
4834 
    oprot.trans.flush()
4835 
 
4836 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4837 
    args = getAllSourcePricing_args()
4838 
    args.read(iprot)
4839 
    iprot.readMessageEnd()
4840 
    result = getAllSourcePricing_result()
4841 
    try:
4842 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4843 
    except CatalogServiceException, cex:
4844 
      result.cex = cex
4845 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4846 
    result.write(oprot)
4847 
    oprot.writeMessageEnd()
4848 
    oprot.trans.flush()
4849 
 
4850 
  def process_getItemForSource(self, seqid, iprot, oprot):
4851 
    args = getItemForSource_args()
4852 
    args.read(iprot)
4853 
    iprot.readMessageEnd()
4854 
    result = getItemForSource_result()
4855 
    try:
4856 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4857 
    except CatalogServiceException, cex:
4858 
      result.cex = cex
4859 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4860 
    result.write(oprot)
4861 
    oprot.writeMessageEnd()
4862 
    oprot.trans.flush()
4863 
 
4864 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4865 
    args = searchItemsInRange_args()
4866 
    args.read(iprot)
4867 
    iprot.readMessageEnd()
4868 
    result = searchItemsInRange_result()
4869 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4870 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4871 
    result.write(oprot)
4872 
    oprot.writeMessageEnd()
4873 
    oprot.trans.flush()
4874 
 
4875 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4876 
    args = getSearchResultCount_args()
4877 
    args.read(iprot)
4878 
    iprot.readMessageEnd()
4879 
    result = getSearchResultCount_result()
4880 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4881 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4882 
    result.write(oprot)
4883 
    oprot.writeMessageEnd()
4884 
    oprot.trans.flush()
4885 
 
4886 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4887 
    args = getProductNotifications_args()
4888 
    args.read(iprot)
4889 
    iprot.readMessageEnd()
4890 
    result = getProductNotifications_result()
4891 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4892 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4893 
    result.write(oprot)
4894 
    oprot.writeMessageEnd()
4895 
    oprot.trans.flush()
4896 
 
4897 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4898 
    args = getProductNotificationRequestCount_args()
4899 
    args.read(iprot)
4900 
    iprot.readMessageEnd()
4901 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 4902 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 4903 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4904 
    result.write(oprot)
4905 
    oprot.writeMessageEnd()
4906 
    oprot.trans.flush()
4907 
 
4908 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4909 
    args = addAuthorizationLog_args()
4910 
    args.read(iprot)
4911 
    iprot.readMessageEnd()
4912 
    result = addAuthorizationLog_result()
4913 
    try:
4914 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4915 
    except CatalogServiceException, cex:
4916 
      result.cex = cex
4917 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4918 
    result.write(oprot)
4919 
    oprot.writeMessageEnd()
4920 
    oprot.trans.flush()
4921 
 
4922 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4923 
    args = addupdateVoucherForItem_args()
4924 
    args.read(iprot)
4925 
    iprot.readMessageEnd()
4926 
    result = addupdateVoucherForItem_result()
4927 
    try:
4928 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4929 
    except CatalogServiceException, cex:
4930 
      result.cex = cex
4931 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4932 
    result.write(oprot)
4933 
    oprot.writeMessageEnd()
4934 
    oprot.trans.flush()
4935 
 
4936 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4937 
    args = deleteVoucherForItem_args()
4938 
    args.read(iprot)
4939 
    iprot.readMessageEnd()
4940 
    result = deleteVoucherForItem_result()
4941 
    try:
4942 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4943 
    except CatalogServiceException, cex:
4944 
      result.cex = cex
4945 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4946 
    result.write(oprot)
4947 
    oprot.writeMessageEnd()
4948 
    oprot.trans.flush()
4949 
 
4950 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4951 
    args = getVoucherAmount_args()
4952 
    args.read(iprot)
4953 
    iprot.readMessageEnd()
4954 
    result = getVoucherAmount_result()
4955 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4956 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4957 
    result.write(oprot)
4958 
    oprot.writeMessageEnd()
4959 
    oprot.trans.flush()
4960 
 
4961 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4962 
    args = getAllItemVouchers_args()
4963 
    args.read(iprot)
4964 
    iprot.readMessageEnd()
4965 
    result = getAllItemVouchers_result()
4966 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4967 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4968 
    result.write(oprot)
4969 
    oprot.writeMessageEnd()
4970 
    oprot.trans.flush()
4971 
 
4972 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4973 
    args = isValidCatalogItemId_args()
4974 
    args.read(iprot)
4975 
    iprot.readMessageEnd()
4976 
    result = isValidCatalogItemId_result()
4977 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4978 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4979 
    result.write(oprot)
4980 
    oprot.writeMessageEnd()
4981 
    oprot.trans.flush()
4982 
 
6039 amit.gupta 4983 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4984 
    args = getVatPercentageForItem_args()
4985 
    args.read(iprot)
4986 
    iprot.readMessageEnd()
4987 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4988 
    try:
4989 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4990 
    except CatalogServiceException, cex:
4991 
      result.cex = cex
6039 amit.gupta 4992 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4993 
    result.write(oprot)
4994 
    oprot.writeMessageEnd()
4995 
    oprot.trans.flush()
5944 mandeep.dh 4996 
 
6039 amit.gupta 4997 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4998 
    args = getVatAmountForItem_args()
4999 
    args.read(iprot)
5000 
    iprot.readMessageEnd()
5001 
    result = getVatAmountForItem_result()
5002 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5003 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
5007 
 
6531 vikram.rag 5008 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5009 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
5012 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5013 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5014 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5015 
    result.write(oprot)
5016 
    oprot.writeMessageEnd()
5017 
    oprot.trans.flush()
6039 amit.gupta 5018 
 
6821 amar.kumar 5019 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5020 
    args = getAllAliveItems_args()
5021 
    args.read(iprot)
5022 
    iprot.readMessageEnd()
5023 
    result = getAllAliveItems_result()
5024 
    result.success = self._handler.getAllAliveItems()
5025 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5026 
    result.write(oprot)
5027 
    oprot.writeMessageEnd()
5028 
    oprot.trans.flush()
5029 
 
6805 anupam.sin 5030 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5031 
    args = getInsuranceAmount_args()
5032 
    args.read(iprot)
5033 
    iprot.readMessageEnd()
5034 
    result = getInsuranceAmount_result()
6921 anupam.sin 5035 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5036 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5037 
    result.write(oprot)
5038 
    oprot.writeMessageEnd()
5039 
    oprot.trans.flush()
6531 vikram.rag 5040 
 
6805 anupam.sin 5041 
  def process_getInsurer(self, seqid, iprot, oprot):
5042 
    args = getInsurer_args()
5043 
    args.read(iprot)
5044 
    iprot.readMessageEnd()
5045 
    result = getInsurer_result()
5046 
    result.success = self._handler.getInsurer(args.insurerId)
5047 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5048 
    result.write(oprot)
5049 
    oprot.writeMessageEnd()
5050 
    oprot.trans.flush()
5051 
 
6838 vikram.rag 5052 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5053 
    args = getAllInsurers_args()
5054 
    args.read(iprot)
5055 
    iprot.readMessageEnd()
5056 
    result = getAllInsurers_result()
5057 
    result.success = self._handler.getAllInsurers()
5058 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
6805 anupam.sin 5062 
 
6962 rajveer 5063 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5064 
    args = updateInsuranceDeclaredAmount_args()
5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
5067 
    result = updateInsuranceDeclaredAmount_result()
5068 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5069 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5070 
    result.write(oprot)
5071 
    oprot.writeMessageEnd()
5072 
    oprot.trans.flush()
6838 vikram.rag 5073 
 
7190 amar.kumar 5074 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5075 
    args = getFreebieForItem_args()
5076 
    args.read(iprot)
5077 
    iprot.readMessageEnd()
5078 
    result = getFreebieForItem_result()
5079 
    result.success = self._handler.getFreebieForItem(args.itemId)
5080 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5081 
    result.write(oprot)
5082 
    oprot.writeMessageEnd()
5083 
    oprot.trans.flush()
6962 rajveer 5084 
 
7190 amar.kumar 5085 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5086 
    args = addOrUpdateFreebieForItem_args()
5087 
    args.read(iprot)
5088 
    iprot.readMessageEnd()
5089 
    result = addOrUpdateFreebieForItem_result()
5090 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5091 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5092 
    result.write(oprot)
5093 
    oprot.writeMessageEnd()
5094 
    oprot.trans.flush()
5095 
 
7272 amit.gupta 5096 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5097 
    args = addOrUpdateBrandInfo_args()
5098 
    args.read(iprot)
5099 
    iprot.readMessageEnd()
5100 
    result = addOrUpdateBrandInfo_result()
5101 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5102 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5103 
    result.write(oprot)
5104 
    oprot.writeMessageEnd()
5105 
    oprot.trans.flush()
5106 
 
5107 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5108 
    args = getBrandInfo_args()
5109 
    args.read(iprot)
5110 
    iprot.readMessageEnd()
5111 
    result = getBrandInfo_result()
5112 
    result.success = self._handler.getBrandInfo()
5113 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5114 
    result.write(oprot)
5115 
    oprot.writeMessageEnd()
5116 
    oprot.trans.flush()
5117 
 
7256 rajveer 5118 
  def process_getStorePricing(self, seqid, iprot, oprot):
5119 
    args = getStorePricing_args()
5120 
    args.read(iprot)
5121 
    iprot.readMessageEnd()
5122 
    result = getStorePricing_result()
5123 
    result.success = self._handler.getStorePricing(args.itemId)
5124 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5125 
    result.write(oprot)
5126 
    oprot.writeMessageEnd()
5127 
    oprot.trans.flush()
7190 amar.kumar 5128 
 
7306 rajveer 5129 
  def process_getStorePricings(self, seqid, iprot, oprot):
5130 
    args = getStorePricings_args()
5131 
    args.read(iprot)
5132 
    iprot.readMessageEnd()
5133 
    result = getStorePricings_result()
5134 
    result.success = self._handler.getStorePricings(args.itemIds)
5135 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5136 
    result.write(oprot)
5137 
    oprot.writeMessageEnd()
5138 
    oprot.trans.flush()
5139 
 
7265 rajveer 5140 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5141 
    args = updateStorePricing_args()
5142 
    args.read(iprot)
5143 
    iprot.readMessageEnd()
5144 
    result = updateStorePricing_result()
7382 rajveer 5145 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5146 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5147 
    result.write(oprot)
5148 
    oprot.writeMessageEnd()
5149 
    oprot.trans.flush()
7256 rajveer 5150 
 
7281 kshitij.so 5151 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5152 
    args = getAllAmazonListedItems_args()
5153 
    args.read(iprot)
5154 
    iprot.readMessageEnd()
5155 
    result = getAllAmazonListedItems_result()
5156 
    result.success = self._handler.getAllAmazonListedItems()
5157 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5158 
    result.write(oprot)
5159 
    oprot.writeMessageEnd()
5160 
    oprot.trans.flush()
7265 rajveer 5161 
 
7281 kshitij.so 5162 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5163 
    args = getAmazonItemDetails_args()
5164 
    args.read(iprot)
5165 
    iprot.readMessageEnd()
5166 
    result = getAmazonItemDetails_result()
5167 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5168 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5169 
    result.write(oprot)
5170 
    oprot.writeMessageEnd()
5171 
    oprot.trans.flush()
5172 
 
5173 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5174 
    args = updateAmazonItemDetails_args()
5175 
    args.read(iprot)
5176 
    iprot.readMessageEnd()
5177 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5178 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5179 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5180 
    result.write(oprot)
5181 
    oprot.writeMessageEnd()
5182 
    oprot.trans.flush()
5183 
 
5184 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5185 
    args = addAmazonItem_args()
5186 
    args.read(iprot)
5187 
    iprot.readMessageEnd()
5188 
    result = addAmazonItem_result()
5189 
    self._handler.addAmazonItem(args.amazonlisted)
5190 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5191 
    result.write(oprot)
5192 
    oprot.writeMessageEnd()
5193 
    oprot.trans.flush()
5194 
 
7291 vikram.rag 5195 
  def process_getAsinItems(self, seqid, iprot, oprot):
5196 
    args = getAsinItems_args()
5197 
    args.read(iprot)
5198 
    iprot.readMessageEnd()
5199 
    result = getAsinItems_result()
5200 
    result.success = self._handler.getAsinItems()
5201 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5202 
    result.write(oprot)
5203 
    oprot.writeMessageEnd()
5204 
    oprot.trans.flush()
7281 kshitij.so 5205 
 
7291 vikram.rag 5206 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5207 
    args = getAllFbaListedItems_args()
5208 
    args.read(iprot)
5209 
    iprot.readMessageEnd()
5210 
    result = getAllFbaListedItems_result()
5211 
    result.success = self._handler.getAllFbaListedItems()
5212 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5213 
    result.write(oprot)
5214 
    oprot.writeMessageEnd()
5215 
    oprot.trans.flush()
5216 
 
5217 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5218 
    args = getAllNonFbaListedItems_args()
5219 
    args.read(iprot)
5220 
    iprot.readMessageEnd()
5221 
    result = getAllNonFbaListedItems_result()
5222 
    result.success = self._handler.getAllNonFbaListedItems()
5223 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5224 
    result.write(oprot)
5225 
    oprot.writeMessageEnd()
5226 
    oprot.trans.flush()
5227 
 
7460 kshitij.so 5228 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5229 
    args = updateItemInventory_args()
5230 
    args.read(iprot)
5231 
    iprot.readMessageEnd()
5232 
    result = updateItemInventory_result()
5233 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5234 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5235 
    result.write(oprot)
5236 
    oprot.writeMessageEnd()
5237 
    oprot.trans.flush()
7291 vikram.rag 5238 
 
7770 kshitij.so 5239 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5240 
    args = updateTimestampForAmazonFeeds_args()
5241 
    args.read(iprot)
5242 
    iprot.readMessageEnd()
5243 
    result = updateTimestampForAmazonFeeds_result()
5244 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5245 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5246 
    result.write(oprot)
5247 
    oprot.writeMessageEnd()
5248 
    oprot.trans.flush()
7460 kshitij.so 5249 
 
7897 amar.kumar 5250 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5251 
    args = getAllParentCategories_args()
5252 
    args.read(iprot)
5253 
    iprot.readMessageEnd()
5254 
    result = getAllParentCategories_result()
5255 
    result.success = self._handler.getAllParentCategories()
5256 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5257 
    result.write(oprot)
5258 
    oprot.writeMessageEnd()
5259 
    oprot.trans.flush()
7770 kshitij.so 5260 
 
7897 amar.kumar 5261 
 
5944 mandeep.dh 5262 
# HELPER FUNCTIONS AND STRUCTURES
5263 
 
5264 
class addItem_args:
5265 
  """
5266 
  Attributes:
5267 
   - item
5268 
  """
5269 
 
5270 
  thrift_spec = (
5271 
    None, # 0
5272 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5273 
  )
5274 
 
5275 
  def __init__(self, item=None,):
5276 
    self.item = item
5277 
 
5278 
  def read(self, iprot):
5279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5281 
      return
5282 
    iprot.readStructBegin()
5283 
    while True:
5284 
      (fname, ftype, fid) = iprot.readFieldBegin()
5285 
      if ftype == TType.STOP:
5286 
        break
5287 
      if fid == 1:
5288 
        if ftype == TType.STRUCT:
5289 
          self.item = Item()
5290 
          self.item.read(iprot)
5291 
        else:
5292 
          iprot.skip(ftype)
5293 
      else:
5294 
        iprot.skip(ftype)
5295 
      iprot.readFieldEnd()
5296 
    iprot.readStructEnd()
5297 
 
5298 
  def write(self, oprot):
5299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5301 
      return
5302 
    oprot.writeStructBegin('addItem_args')
5303 
    if self.item is not None:
5304 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5305 
      self.item.write(oprot)
5306 
      oprot.writeFieldEnd()
5307 
    oprot.writeFieldStop()
5308 
    oprot.writeStructEnd()
5309 
 
5310 
  def validate(self):
5311 
    return
5312 
 
5313 
 
5314 
  def __repr__(self):
5315 
    L = ['%s=%r' % (key, value)
5316 
      for key, value in self.__dict__.iteritems()]
5317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5318 
 
5319 
  def __eq__(self, other):
5320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5321 
 
5322 
  def __ne__(self, other):
5323 
    return not (self == other)
5324 
 
5325 
class addItem_result:
5326 
  """
5327 
  Attributes:
5328 
   - success
5329 
   - cex
5330 
  """
5331 
 
5332 
  thrift_spec = (
5333 
    (0, TType.I64, 'success', None, None, ), # 0
5334 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5335 
  )
5336 
 
5337 
  def __init__(self, success=None, cex=None,):
5338 
    self.success = success
5339 
    self.cex = cex
5340 
 
5341 
  def read(self, iprot):
5342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5344 
      return
5345 
    iprot.readStructBegin()
5346 
    while True:
5347 
      (fname, ftype, fid) = iprot.readFieldBegin()
5348 
      if ftype == TType.STOP:
5349 
        break
5350 
      if fid == 0:
5351 
        if ftype == TType.I64:
5352 
          self.success = iprot.readI64();
5353 
        else:
5354 
          iprot.skip(ftype)
5355 
      elif fid == 1:
5356 
        if ftype == TType.STRUCT:
5357 
          self.cex = CatalogServiceException()
5358 
          self.cex.read(iprot)
5359 
        else:
5360 
          iprot.skip(ftype)
5361 
      else:
5362 
        iprot.skip(ftype)
5363 
      iprot.readFieldEnd()
5364 
    iprot.readStructEnd()
5365 
 
5366 
  def write(self, oprot):
5367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5369 
      return
5370 
    oprot.writeStructBegin('addItem_result')
5371 
    if self.success is not None:
5372 
      oprot.writeFieldBegin('success', TType.I64, 0)
5373 
      oprot.writeI64(self.success)
5374 
      oprot.writeFieldEnd()
5375 
    if self.cex is not None:
5376 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5377 
      self.cex.write(oprot)
5378 
      oprot.writeFieldEnd()
5379 
    oprot.writeFieldStop()
5380 
    oprot.writeStructEnd()
5381 
 
5382 
  def validate(self):
5383 
    return
5384 
 
5385 
 
5386 
  def __repr__(self):
5387 
    L = ['%s=%r' % (key, value)
5388 
      for key, value in self.__dict__.iteritems()]
5389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5390 
 
5391 
  def __eq__(self, other):
5392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5393 
 
5394 
  def __ne__(self, other):
5395 
    return not (self == other)
5396 
 
5397 
class updateItem_args:
5398 
  """
5399 
  Attributes:
5400 
   - item
5401 
  """
5402 
 
5403 
  thrift_spec = (
5404 
    None, # 0
5405 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5406 
  )
5407 
 
5408 
  def __init__(self, item=None,):
5409 
    self.item = item
5410 
 
5411 
  def read(self, iprot):
5412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5414 
      return
5415 
    iprot.readStructBegin()
5416 
    while True:
5417 
      (fname, ftype, fid) = iprot.readFieldBegin()
5418 
      if ftype == TType.STOP:
5419 
        break
5420 
      if fid == 1:
5421 
        if ftype == TType.STRUCT:
5422 
          self.item = Item()
5423 
          self.item.read(iprot)
5424 
        else:
5425 
          iprot.skip(ftype)
5426 
      else:
5427 
        iprot.skip(ftype)
5428 
      iprot.readFieldEnd()
5429 
    iprot.readStructEnd()
5430 
 
5431 
  def write(self, oprot):
5432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5434 
      return
5435 
    oprot.writeStructBegin('updateItem_args')
5436 
    if self.item is not None:
5437 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5438 
      self.item.write(oprot)
5439 
      oprot.writeFieldEnd()
5440 
    oprot.writeFieldStop()
5441 
    oprot.writeStructEnd()
5442 
 
5443 
  def validate(self):
5444 
    return
5445 
 
5446 
 
5447 
  def __repr__(self):
5448 
    L = ['%s=%r' % (key, value)
5449 
      for key, value in self.__dict__.iteritems()]
5450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5451 
 
5452 
  def __eq__(self, other):
5453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5454 
 
5455 
  def __ne__(self, other):
5456 
    return not (self == other)
5457 
 
5458 
class updateItem_result:
5459 
  """
5460 
  Attributes:
5461 
   - success
5462 
   - cex
5463 
  """
5464 
 
5465 
  thrift_spec = (
5466 
    (0, TType.I64, 'success', None, None, ), # 0
5467 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5468 
  )
5469 
 
5470 
  def __init__(self, success=None, cex=None,):
5471 
    self.success = success
5472 
    self.cex = cex
5473 
 
5474 
  def read(self, iprot):
5475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5477 
      return
5478 
    iprot.readStructBegin()
5479 
    while True:
5480 
      (fname, ftype, fid) = iprot.readFieldBegin()
5481 
      if ftype == TType.STOP:
5482 
        break
5483 
      if fid == 0:
5484 
        if ftype == TType.I64:
5485 
          self.success = iprot.readI64();
5486 
        else:
5487 
          iprot.skip(ftype)
5488 
      elif fid == 1:
5489 
        if ftype == TType.STRUCT:
5490 
          self.cex = CatalogServiceException()
5491 
          self.cex.read(iprot)
5492 
        else:
5493 
          iprot.skip(ftype)
5494 
      else:
5495 
        iprot.skip(ftype)
5496 
      iprot.readFieldEnd()
5497 
    iprot.readStructEnd()
5498 
 
5499 
  def write(self, oprot):
5500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5502 
      return
5503 
    oprot.writeStructBegin('updateItem_result')
5504 
    if self.success is not None:
5505 
      oprot.writeFieldBegin('success', TType.I64, 0)
5506 
      oprot.writeI64(self.success)
5507 
      oprot.writeFieldEnd()
5508 
    if self.cex is not None:
5509 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5510 
      self.cex.write(oprot)
5511 
      oprot.writeFieldEnd()
5512 
    oprot.writeFieldStop()
5513 
    oprot.writeStructEnd()
5514 
 
5515 
  def validate(self):
5516 
    return
5517 
 
5518 
 
5519 
  def __repr__(self):
5520 
    L = ['%s=%r' % (key, value)
5521 
      for key, value in self.__dict__.iteritems()]
5522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5523 
 
5524 
  def __eq__(self, other):
5525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5526 
 
5527 
  def __ne__(self, other):
5528 
    return not (self == other)
5529 
 
5530 
class isActive_args:
5531 
  """
5532 
  Attributes:
5533 
   - itemId
5534 
  """
5535 
 
5536 
  thrift_spec = (
5537 
    None, # 0
5538 
    (1, TType.I64, 'itemId', None, None, ), # 1
5539 
  )
5540 
 
5541 
  def __init__(self, itemId=None,):
5542 
    self.itemId = itemId
5543 
 
5544 
  def read(self, iprot):
5545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5547 
      return
5548 
    iprot.readStructBegin()
5549 
    while True:
5550 
      (fname, ftype, fid) = iprot.readFieldBegin()
5551 
      if ftype == TType.STOP:
5552 
        break
5553 
      if fid == 1:
5554 
        if ftype == TType.I64:
5555 
          self.itemId = iprot.readI64();
5556 
        else:
5557 
          iprot.skip(ftype)
5558 
      else:
5559 
        iprot.skip(ftype)
5560 
      iprot.readFieldEnd()
5561 
    iprot.readStructEnd()
5562 
 
5563 
  def write(self, oprot):
5564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5566 
      return
5567 
    oprot.writeStructBegin('isActive_args')
5568 
    if self.itemId is not None:
5569 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5570 
      oprot.writeI64(self.itemId)
5571 
      oprot.writeFieldEnd()
5572 
    oprot.writeFieldStop()
5573 
    oprot.writeStructEnd()
5574 
 
5575 
  def validate(self):
5576 
    return
5577 
 
5578 
 
5579 
  def __repr__(self):
5580 
    L = ['%s=%r' % (key, value)
5581 
      for key, value in self.__dict__.iteritems()]
5582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5583 
 
5584 
  def __eq__(self, other):
5585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5586 
 
5587 
  def __ne__(self, other):
5588 
    return not (self == other)
5589 
 
5590 
class isActive_result:
5591 
  """
5592 
  Attributes:
5593 
   - success
5594 
   - isex
5595 
  """
5596 
 
5597 
  thrift_spec = (
5598 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5599 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5600 
  )
5601 
 
5602 
  def __init__(self, success=None, isex=None,):
5603 
    self.success = success
5604 
    self.isex = isex
5605 
 
5606 
  def read(self, iprot):
5607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5609 
      return
5610 
    iprot.readStructBegin()
5611 
    while True:
5612 
      (fname, ftype, fid) = iprot.readFieldBegin()
5613 
      if ftype == TType.STOP:
5614 
        break
5615 
      if fid == 0:
5616 
        if ftype == TType.STRUCT:
5617 
          self.success = ItemShippingInfo()
5618 
          self.success.read(iprot)
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      elif fid == 1:
5622 
        if ftype == TType.STRUCT:
5623 
          self.isex = CatalogServiceException()
5624 
          self.isex.read(iprot)
5625 
        else:
5626 
          iprot.skip(ftype)
5627 
      else:
5628 
        iprot.skip(ftype)
5629 
      iprot.readFieldEnd()
5630 
    iprot.readStructEnd()
5631 
 
5632 
  def write(self, oprot):
5633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5635 
      return
5636 
    oprot.writeStructBegin('isActive_result')
5637 
    if self.success is not None:
5638 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5639 
      self.success.write(oprot)
5640 
      oprot.writeFieldEnd()
5641 
    if self.isex is not None:
5642 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5643 
      self.isex.write(oprot)
5644 
      oprot.writeFieldEnd()
5645 
    oprot.writeFieldStop()
5646 
    oprot.writeStructEnd()
5647 
 
5648 
  def validate(self):
5649 
    return
5650 
 
5651 
 
5652 
  def __repr__(self):
5653 
    L = ['%s=%r' % (key, value)
5654 
      for key, value in self.__dict__.iteritems()]
5655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5656 
 
5657 
  def __eq__(self, other):
5658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5659 
 
5660 
  def __ne__(self, other):
5661 
    return not (self == other)
5662 
 
7438 amit.gupta 5663 
class getItemsStatus_args:
5664 
  """
5665 
  Attributes:
5666 
   - itemIds
5667 
  """
5668 
 
5669 
  thrift_spec = (
5670 
    None, # 0
5671 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5672 
  )
5673 
 
5674 
  def __init__(self, itemIds=None,):
5675 
    self.itemIds = itemIds
5676 
 
5677 
  def read(self, iprot):
5678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5680 
      return
5681 
    iprot.readStructBegin()
5682 
    while True:
5683 
      (fname, ftype, fid) = iprot.readFieldBegin()
5684 
      if ftype == TType.STOP:
5685 
        break
5686 
      if fid == 1:
5687 
        if ftype == TType.LIST:
5688 
          self.itemIds = []
5689 
          (_etype19, _size16) = iprot.readListBegin()
5690 
          for _i20 in xrange(_size16):
5691 
            _elem21 = iprot.readI64();
5692 
            self.itemIds.append(_elem21)
5693 
          iprot.readListEnd()
5694 
        else:
5695 
          iprot.skip(ftype)
5696 
      else:
5697 
        iprot.skip(ftype)
5698 
      iprot.readFieldEnd()
5699 
    iprot.readStructEnd()
5700 
 
5701 
  def write(self, oprot):
5702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5704 
      return
5705 
    oprot.writeStructBegin('getItemsStatus_args')
5706 
    if self.itemIds is not None:
5707 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5708 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5709 
      for iter22 in self.itemIds:
5710 
        oprot.writeI64(iter22)
5711 
      oprot.writeListEnd()
5712 
      oprot.writeFieldEnd()
5713 
    oprot.writeFieldStop()
5714 
    oprot.writeStructEnd()
5715 
 
5716 
  def validate(self):
5717 
    return
5718 
 
5719 
 
5720 
  def __repr__(self):
5721 
    L = ['%s=%r' % (key, value)
5722 
      for key, value in self.__dict__.iteritems()]
5723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5724 
 
5725 
  def __eq__(self, other):
5726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5727 
 
5728 
  def __ne__(self, other):
5729 
    return not (self == other)
5730 
 
5731 
class getItemsStatus_result:
5732 
  """
5733 
  Attributes:
5734 
   - success
5735 
   - isex
5736 
  """
5737 
 
5738 
  thrift_spec = (
5739 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5740 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5741 
  )
5742 
 
5743 
  def __init__(self, success=None, isex=None,):
5744 
    self.success = success
5745 
    self.isex = isex
5746 
 
5747 
  def read(self, iprot):
5748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5750 
      return
5751 
    iprot.readStructBegin()
5752 
    while True:
5753 
      (fname, ftype, fid) = iprot.readFieldBegin()
5754 
      if ftype == TType.STOP:
5755 
        break
5756 
      if fid == 0:
5757 
        if ftype == TType.MAP:
5758 
          self.success = {}
5759 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5760 
          for _i27 in xrange(_size23):
5761 
            _key28 = iprot.readI64();
5762 
            _val29 = iprot.readBool();
5763 
            self.success[_key28] = _val29
5764 
          iprot.readMapEnd()
5765 
        else:
5766 
          iprot.skip(ftype)
5767 
      elif fid == 1:
5768 
        if ftype == TType.STRUCT:
5769 
          self.isex = CatalogServiceException()
5770 
          self.isex.read(iprot)
5771 
        else:
5772 
          iprot.skip(ftype)
5773 
      else:
5774 
        iprot.skip(ftype)
5775 
      iprot.readFieldEnd()
5776 
    iprot.readStructEnd()
5777 
 
5778 
  def write(self, oprot):
5779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5781 
      return
5782 
    oprot.writeStructBegin('getItemsStatus_result')
5783 
    if self.success is not None:
5784 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5785 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5786 
      for kiter30,viter31 in self.success.items():
5787 
        oprot.writeI64(kiter30)
5788 
        oprot.writeBool(viter31)
5789 
      oprot.writeMapEnd()
5790 
      oprot.writeFieldEnd()
5791 
    if self.isex is not None:
5792 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5793 
      self.isex.write(oprot)
5794 
      oprot.writeFieldEnd()
5795 
    oprot.writeFieldStop()
5796 
    oprot.writeStructEnd()
5797 
 
5798 
  def validate(self):
5799 
    return
5800 
 
5801 
 
5802 
  def __repr__(self):
5803 
    L = ['%s=%r' % (key, value)
5804 
      for key, value in self.__dict__.iteritems()]
5805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5806 
 
5807 
  def __eq__(self, other):
5808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5809 
 
5810 
  def __ne__(self, other):
5811 
    return not (self == other)
5812 
 
5944 mandeep.dh 5813 
class getItemStatusDescription_args:
5814 
  """
5815 
  Attributes:
5816 
   - itemId
5817 
  """
5818 
 
5819 
  thrift_spec = (
5820 
    None, # 0
5821 
    (1, TType.I64, 'itemId', None, None, ), # 1
5822 
  )
5823 
 
5824 
  def __init__(self, itemId=None,):
5825 
    self.itemId = itemId
5826 
 
5827 
  def read(self, iprot):
5828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5830 
      return
5831 
    iprot.readStructBegin()
5832 
    while True:
5833 
      (fname, ftype, fid) = iprot.readFieldBegin()
5834 
      if ftype == TType.STOP:
5835 
        break
5836 
      if fid == 1:
5837 
        if ftype == TType.I64:
5838 
          self.itemId = iprot.readI64();
5839 
        else:
5840 
          iprot.skip(ftype)
5841 
      else:
5842 
        iprot.skip(ftype)
5843 
      iprot.readFieldEnd()
5844 
    iprot.readStructEnd()
5845 
 
5846 
  def write(self, oprot):
5847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5849 
      return
5850 
    oprot.writeStructBegin('getItemStatusDescription_args')
5851 
    if self.itemId is not None:
5852 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5853 
      oprot.writeI64(self.itemId)
5854 
      oprot.writeFieldEnd()
5855 
    oprot.writeFieldStop()
5856 
    oprot.writeStructEnd()
5857 
 
5858 
  def validate(self):
5859 
    return
5860 
 
5861 
 
5862 
  def __repr__(self):
5863 
    L = ['%s=%r' % (key, value)
5864 
      for key, value in self.__dict__.iteritems()]
5865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5866 
 
5867 
  def __eq__(self, other):
5868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5869 
 
5870 
  def __ne__(self, other):
5871 
    return not (self == other)
5872 
 
5873 
class getItemStatusDescription_result:
5874 
  """
5875 
  Attributes:
5876 
   - success
5877 
   - isex
5878 
  """
5879 
 
5880 
  thrift_spec = (
5881 
    (0, TType.STRING, 'success', None, None, ), # 0
5882 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5883 
  )
5884 
 
5885 
  def __init__(self, success=None, isex=None,):
5886 
    self.success = success
5887 
    self.isex = isex
5888 
 
5889 
  def read(self, iprot):
5890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5892 
      return
5893 
    iprot.readStructBegin()
5894 
    while True:
5895 
      (fname, ftype, fid) = iprot.readFieldBegin()
5896 
      if ftype == TType.STOP:
5897 
        break
5898 
      if fid == 0:
5899 
        if ftype == TType.STRING:
5900 
          self.success = iprot.readString();
5901 
        else:
5902 
          iprot.skip(ftype)
5903 
      elif fid == 1:
5904 
        if ftype == TType.STRUCT:
5905 
          self.isex = CatalogServiceException()
5906 
          self.isex.read(iprot)
5907 
        else:
5908 
          iprot.skip(ftype)
5909 
      else:
5910 
        iprot.skip(ftype)
5911 
      iprot.readFieldEnd()
5912 
    iprot.readStructEnd()
5913 
 
5914 
  def write(self, oprot):
5915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5917 
      return
5918 
    oprot.writeStructBegin('getItemStatusDescription_result')
5919 
    if self.success is not None:
5920 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5921 
      oprot.writeString(self.success)
5922 
      oprot.writeFieldEnd()
5923 
    if self.isex is not None:
5924 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5925 
      self.isex.write(oprot)
5926 
      oprot.writeFieldEnd()
5927 
    oprot.writeFieldStop()
5928 
    oprot.writeStructEnd()
5929 
 
5930 
  def validate(self):
5931 
    return
5932 
 
5933 
 
5934 
  def __repr__(self):
5935 
    L = ['%s=%r' % (key, value)
5936 
      for key, value in self.__dict__.iteritems()]
5937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5938 
 
5939 
  def __eq__(self, other):
5940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5941 
 
5942 
  def __ne__(self, other):
5943 
    return not (self == other)
5944 
 
5945 
class startItemOn_args:
5946 
  """
5947 
  Attributes:
5948 
   - item_id
5949 
   - timestamp
5950 
  """
5951 
 
5952 
  thrift_spec = (
5953 
    None, # 0
5954 
    (1, TType.I64, 'item_id', None, None, ), # 1
5955 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5956 
  )
5957 
 
5958 
  def __init__(self, item_id=None, timestamp=None,):
5959 
    self.item_id = item_id
5960 
    self.timestamp = timestamp
5961 
 
5962 
  def read(self, iprot):
5963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5965 
      return
5966 
    iprot.readStructBegin()
5967 
    while True:
5968 
      (fname, ftype, fid) = iprot.readFieldBegin()
5969 
      if ftype == TType.STOP:
5970 
        break
5971 
      if fid == 1:
5972 
        if ftype == TType.I64:
5973 
          self.item_id = iprot.readI64();
5974 
        else:
5975 
          iprot.skip(ftype)
5976 
      elif fid == 2:
5977 
        if ftype == TType.I64:
5978 
          self.timestamp = iprot.readI64();
5979 
        else:
5980 
          iprot.skip(ftype)
5981 
      else:
5982 
        iprot.skip(ftype)
5983 
      iprot.readFieldEnd()
5984 
    iprot.readStructEnd()
5985 
 
5986 
  def write(self, oprot):
5987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5989 
      return
5990 
    oprot.writeStructBegin('startItemOn_args')
5991 
    if self.item_id is not None:
5992 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5993 
      oprot.writeI64(self.item_id)
5994 
      oprot.writeFieldEnd()
5995 
    if self.timestamp is not None:
5996 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5997 
      oprot.writeI64(self.timestamp)
5998 
      oprot.writeFieldEnd()
5999 
    oprot.writeFieldStop()
6000 
    oprot.writeStructEnd()
6001 
 
6002 
  def validate(self):
6003 
    return
6004 
 
6005 
 
6006 
  def __repr__(self):
6007 
    L = ['%s=%r' % (key, value)
6008 
      for key, value in self.__dict__.iteritems()]
6009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6010 
 
6011 
  def __eq__(self, other):
6012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6013 
 
6014 
  def __ne__(self, other):
6015 
    return not (self == other)
6016 
 
6017 
class startItemOn_result:
6018 
  """
6019 
  Attributes:
6020 
   - cex
6021 
  """
6022 
 
6023 
  thrift_spec = (
6024 
    None, # 0
6025 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6026 
  )
6027 
 
6028 
  def __init__(self, cex=None,):
6029 
    self.cex = cex
6030 
 
6031 
  def read(self, iprot):
6032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6034 
      return
6035 
    iprot.readStructBegin()
6036 
    while True:
6037 
      (fname, ftype, fid) = iprot.readFieldBegin()
6038 
      if ftype == TType.STOP:
6039 
        break
6040 
      if fid == 1:
6041 
        if ftype == TType.STRUCT:
6042 
          self.cex = CatalogServiceException()
6043 
          self.cex.read(iprot)
6044 
        else:
6045 
          iprot.skip(ftype)
6046 
      else:
6047 
        iprot.skip(ftype)
6048 
      iprot.readFieldEnd()
6049 
    iprot.readStructEnd()
6050 
 
6051 
  def write(self, oprot):
6052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6054 
      return
6055 
    oprot.writeStructBegin('startItemOn_result')
6056 
    if self.cex is not None:
6057 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6058 
      self.cex.write(oprot)
6059 
      oprot.writeFieldEnd()
6060 
    oprot.writeFieldStop()
6061 
    oprot.writeStructEnd()
6062 
 
6063 
  def validate(self):
6064 
    return
6065 
 
6066 
 
6067 
  def __repr__(self):
6068 
    L = ['%s=%r' % (key, value)
6069 
      for key, value in self.__dict__.iteritems()]
6070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6071 
 
6072 
  def __eq__(self, other):
6073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6074 
 
6075 
  def __ne__(self, other):
6076 
    return not (self == other)
6077 
 
6078 
class retireItemOn_args:
6079 
  """
6080 
  Attributes:
6081 
   - item_id
6082 
   - timestamp
6083 
  """
6084 
 
6085 
  thrift_spec = (
6086 
    None, # 0
6087 
    (1, TType.I64, 'item_id', None, None, ), # 1
6088 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6089 
  )
6090 
 
6091 
  def __init__(self, item_id=None, timestamp=None,):
6092 
    self.item_id = item_id
6093 
    self.timestamp = timestamp
6094 
 
6095 
  def read(self, iprot):
6096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6098 
      return
6099 
    iprot.readStructBegin()
6100 
    while True:
6101 
      (fname, ftype, fid) = iprot.readFieldBegin()
6102 
      if ftype == TType.STOP:
6103 
        break
6104 
      if fid == 1:
6105 
        if ftype == TType.I64:
6106 
          self.item_id = iprot.readI64();
6107 
        else:
6108 
          iprot.skip(ftype)
6109 
      elif fid == 2:
6110 
        if ftype == TType.I64:
6111 
          self.timestamp = iprot.readI64();
6112 
        else:
6113 
          iprot.skip(ftype)
6114 
      else:
6115 
        iprot.skip(ftype)
6116 
      iprot.readFieldEnd()
6117 
    iprot.readStructEnd()
6118 
 
6119 
  def write(self, oprot):
6120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6122 
      return
6123 
    oprot.writeStructBegin('retireItemOn_args')
6124 
    if self.item_id is not None:
6125 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6126 
      oprot.writeI64(self.item_id)
6127 
      oprot.writeFieldEnd()
6128 
    if self.timestamp is not None:
6129 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6130 
      oprot.writeI64(self.timestamp)
6131 
      oprot.writeFieldEnd()
6132 
    oprot.writeFieldStop()
6133 
    oprot.writeStructEnd()
6134 
 
6135 
  def validate(self):
6136 
    return
6137 
 
6138 
 
6139 
  def __repr__(self):
6140 
    L = ['%s=%r' % (key, value)
6141 
      for key, value in self.__dict__.iteritems()]
6142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6143 
 
6144 
  def __eq__(self, other):
6145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6146 
 
6147 
  def __ne__(self, other):
6148 
    return not (self == other)
6149 
 
6150 
class retireItemOn_result:
6151 
  """
6152 
  Attributes:
6153 
   - cex
6154 
  """
6155 
 
6156 
  thrift_spec = (
6157 
    None, # 0
6158 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6159 
  )
6160 
 
6161 
  def __init__(self, cex=None,):
6162 
    self.cex = cex
6163 
 
6164 
  def read(self, iprot):
6165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6167 
      return
6168 
    iprot.readStructBegin()
6169 
    while True:
6170 
      (fname, ftype, fid) = iprot.readFieldBegin()
6171 
      if ftype == TType.STOP:
6172 
        break
6173 
      if fid == 1:
6174 
        if ftype == TType.STRUCT:
6175 
          self.cex = CatalogServiceException()
6176 
          self.cex.read(iprot)
6177 
        else:
6178 
          iprot.skip(ftype)
6179 
      else:
6180 
        iprot.skip(ftype)
6181 
      iprot.readFieldEnd()
6182 
    iprot.readStructEnd()
6183 
 
6184 
  def write(self, oprot):
6185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6187 
      return
6188 
    oprot.writeStructBegin('retireItemOn_result')
6189 
    if self.cex is not None:
6190 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6191 
      self.cex.write(oprot)
6192 
      oprot.writeFieldEnd()
6193 
    oprot.writeFieldStop()
6194 
    oprot.writeStructEnd()
6195 
 
6196 
  def validate(self):
6197 
    return
6198 
 
6199 
 
6200 
  def __repr__(self):
6201 
    L = ['%s=%r' % (key, value)
6202 
      for key, value in self.__dict__.iteritems()]
6203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6204 
 
6205 
  def __eq__(self, other):
6206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6207 
 
6208 
  def __ne__(self, other):
6209 
    return not (self == other)
6210 
 
6211 
class changeItemStatus_args:
6212 
  """
6213 
  Attributes:
6214 
   - item_id
6215 
   - timestamp
6216 
   - newstatus
6217 
  """
6218 
 
6219 
  thrift_spec = (
6220 
    None, # 0
6221 
    (1, TType.I64, 'item_id', None, None, ), # 1
6222 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6223 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6224 
  )
6225 
 
6226 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6227 
    self.item_id = item_id
6228 
    self.timestamp = timestamp
6229 
    self.newstatus = newstatus
6230 
 
6231 
  def read(self, iprot):
6232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6234 
      return
6235 
    iprot.readStructBegin()
6236 
    while True:
6237 
      (fname, ftype, fid) = iprot.readFieldBegin()
6238 
      if ftype == TType.STOP:
6239 
        break
6240 
      if fid == 1:
6241 
        if ftype == TType.I64:
6242 
          self.item_id = iprot.readI64();
6243 
        else:
6244 
          iprot.skip(ftype)
6245 
      elif fid == 2:
6246 
        if ftype == TType.I64:
6247 
          self.timestamp = iprot.readI64();
6248 
        else:
6249 
          iprot.skip(ftype)
6250 
      elif fid == 3:
6251 
        if ftype == TType.I32:
6252 
          self.newstatus = iprot.readI32();
6253 
        else:
6254 
          iprot.skip(ftype)
6255 
      else:
6256 
        iprot.skip(ftype)
6257 
      iprot.readFieldEnd()
6258 
    iprot.readStructEnd()
6259 
 
6260 
  def write(self, oprot):
6261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6263 
      return
6264 
    oprot.writeStructBegin('changeItemStatus_args')
6265 
    if self.item_id is not None:
6266 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6267 
      oprot.writeI64(self.item_id)
6268 
      oprot.writeFieldEnd()
6269 
    if self.timestamp is not None:
6270 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6271 
      oprot.writeI64(self.timestamp)
6272 
      oprot.writeFieldEnd()
6273 
    if self.newstatus is not None:
6274 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6275 
      oprot.writeI32(self.newstatus)
6276 
      oprot.writeFieldEnd()
6277 
    oprot.writeFieldStop()
6278 
    oprot.writeStructEnd()
6279 
 
6280 
  def validate(self):
6281 
    return
6282 
 
6283 
 
6284 
  def __repr__(self):
6285 
    L = ['%s=%r' % (key, value)
6286 
      for key, value in self.__dict__.iteritems()]
6287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6288 
 
6289 
  def __eq__(self, other):
6290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6291 
 
6292 
  def __ne__(self, other):
6293 
    return not (self == other)
6294 
 
6295 
class changeItemStatus_result:
6296 
  """
6297 
  Attributes:
6298 
   - cex
6299 
  """
6300 
 
6301 
  thrift_spec = (
6302 
    None, # 0
6303 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6304 
  )
6305 
 
6306 
  def __init__(self, cex=None,):
6307 
    self.cex = cex
6308 
 
6309 
  def read(self, iprot):
6310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6312 
      return
6313 
    iprot.readStructBegin()
6314 
    while True:
6315 
      (fname, ftype, fid) = iprot.readFieldBegin()
6316 
      if ftype == TType.STOP:
6317 
        break
6318 
      if fid == 1:
6319 
        if ftype == TType.STRUCT:
6320 
          self.cex = CatalogServiceException()
6321 
          self.cex.read(iprot)
6322 
        else:
6323 
          iprot.skip(ftype)
6324 
      else:
6325 
        iprot.skip(ftype)
6326 
      iprot.readFieldEnd()
6327 
    iprot.readStructEnd()
6328 
 
6329 
  def write(self, oprot):
6330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6332 
      return
6333 
    oprot.writeStructBegin('changeItemStatus_result')
6334 
    if self.cex is not None:
6335 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6336 
      self.cex.write(oprot)
6337 
      oprot.writeFieldEnd()
6338 
    oprot.writeFieldStop()
6339 
    oprot.writeStructEnd()
6340 
 
6341 
  def validate(self):
6342 
    return
6343 
 
6344 
 
6345 
  def __repr__(self):
6346 
    L = ['%s=%r' % (key, value)
6347 
      for key, value in self.__dict__.iteritems()]
6348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6349 
 
6350 
  def __eq__(self, other):
6351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6352 
 
6353 
  def __ne__(self, other):
6354 
    return not (self == other)
6355 
 
6356 
class getItem_args:
6357 
  """
6358 
  Attributes:
6359 
   - item_id
6360 
  """
6361 
 
6362 
  thrift_spec = (
6363 
    None, # 0
6364 
    (1, TType.I64, 'item_id', None, None, ), # 1
6365 
  )
6366 
 
6367 
  def __init__(self, item_id=None,):
6368 
    self.item_id = item_id
6369 
 
6370 
  def read(self, iprot):
6371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6373 
      return
6374 
    iprot.readStructBegin()
6375 
    while True:
6376 
      (fname, ftype, fid) = iprot.readFieldBegin()
6377 
      if ftype == TType.STOP:
6378 
        break
6379 
      if fid == 1:
6380 
        if ftype == TType.I64:
6381 
          self.item_id = iprot.readI64();
6382 
        else:
6383 
          iprot.skip(ftype)
6384 
      else:
6385 
        iprot.skip(ftype)
6386 
      iprot.readFieldEnd()
6387 
    iprot.readStructEnd()
6388 
 
6389 
  def write(self, oprot):
6390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6392 
      return
6393 
    oprot.writeStructBegin('getItem_args')
6394 
    if self.item_id is not None:
6395 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6396 
      oprot.writeI64(self.item_id)
6397 
      oprot.writeFieldEnd()
6398 
    oprot.writeFieldStop()
6399 
    oprot.writeStructEnd()
6400 
 
6401 
  def validate(self):
6402 
    return
6403 
 
6404 
 
6405 
  def __repr__(self):
6406 
    L = ['%s=%r' % (key, value)
6407 
      for key, value in self.__dict__.iteritems()]
6408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6409 
 
6410 
  def __eq__(self, other):
6411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6412 
 
6413 
  def __ne__(self, other):
6414 
    return not (self == other)
6415 
 
6416 
class getItem_result:
6417 
  """
6418 
  Attributes:
6419 
   - success
6420 
   - cex
6421 
  """
6422 
 
6423 
  thrift_spec = (
6424 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6425 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6426 
  )
6427 
 
6428 
  def __init__(self, success=None, cex=None,):
6429 
    self.success = success
6430 
    self.cex = cex
6431 
 
6432 
  def read(self, iprot):
6433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6435 
      return
6436 
    iprot.readStructBegin()
6437 
    while True:
6438 
      (fname, ftype, fid) = iprot.readFieldBegin()
6439 
      if ftype == TType.STOP:
6440 
        break
6441 
      if fid == 0:
6442 
        if ftype == TType.STRUCT:
6443 
          self.success = Item()
6444 
          self.success.read(iprot)
6445 
        else:
6446 
          iprot.skip(ftype)
6447 
      elif fid == 1:
6448 
        if ftype == TType.STRUCT:
6449 
          self.cex = CatalogServiceException()
6450 
          self.cex.read(iprot)
6451 
        else:
6452 
          iprot.skip(ftype)
6453 
      else:
6454 
        iprot.skip(ftype)
6455 
      iprot.readFieldEnd()
6456 
    iprot.readStructEnd()
6457 
 
6458 
  def write(self, oprot):
6459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6461 
      return
6462 
    oprot.writeStructBegin('getItem_result')
6463 
    if self.success is not None:
6464 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6465 
      self.success.write(oprot)
6466 
      oprot.writeFieldEnd()
6467 
    if self.cex is not None:
6468 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6469 
      self.cex.write(oprot)
6470 
      oprot.writeFieldEnd()
6471 
    oprot.writeFieldStop()
6472 
    oprot.writeStructEnd()
6473 
 
6474 
  def validate(self):
6475 
    return
6476 
 
6477 
 
6478 
  def __repr__(self):
6479 
    L = ['%s=%r' % (key, value)
6480 
      for key, value in self.__dict__.iteritems()]
6481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6482 
 
6483 
  def __eq__(self, other):
6484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6485 
 
6486 
  def __ne__(self, other):
6487 
    return not (self == other)
6488 
 
6489 
class getItemsByCatalogId_args:
6490 
  """
6491 
  Attributes:
6492 
   - catalog_item_id
6493 
  """
6494 
 
6495 
  thrift_spec = (
6496 
    None, # 0
6497 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6498 
  )
6499 
 
6500 
  def __init__(self, catalog_item_id=None,):
6501 
    self.catalog_item_id = catalog_item_id
6502 
 
6503 
  def read(self, iprot):
6504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6506 
      return
6507 
    iprot.readStructBegin()
6508 
    while True:
6509 
      (fname, ftype, fid) = iprot.readFieldBegin()
6510 
      if ftype == TType.STOP:
6511 
        break
6512 
      if fid == 1:
6513 
        if ftype == TType.I64:
6514 
          self.catalog_item_id = iprot.readI64();
6515 
        else:
6516 
          iprot.skip(ftype)
6517 
      else:
6518 
        iprot.skip(ftype)
6519 
      iprot.readFieldEnd()
6520 
    iprot.readStructEnd()
6521 
 
6522 
  def write(self, oprot):
6523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6525 
      return
6526 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6527 
    if self.catalog_item_id is not None:
6528 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6529 
      oprot.writeI64(self.catalog_item_id)
6530 
      oprot.writeFieldEnd()
6531 
    oprot.writeFieldStop()
6532 
    oprot.writeStructEnd()
6533 
 
6534 
  def validate(self):
6535 
    return
6536 
 
6537 
 
6538 
  def __repr__(self):
6539 
    L = ['%s=%r' % (key, value)
6540 
      for key, value in self.__dict__.iteritems()]
6541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6542 
 
6543 
  def __eq__(self, other):
6544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6545 
 
6546 
  def __ne__(self, other):
6547 
    return not (self == other)
6548 
 
6549 
class getItemsByCatalogId_result:
6550 
  """
6551 
  Attributes:
6552 
   - success
6553 
   - cex
6554 
  """
6555 
 
6556 
  thrift_spec = (
6557 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6558 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6559 
  )
6560 
 
6561 
  def __init__(self, success=None, cex=None,):
6562 
    self.success = success
6563 
    self.cex = cex
6564 
 
6565 
  def read(self, iprot):
6566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6568 
      return
6569 
    iprot.readStructBegin()
6570 
    while True:
6571 
      (fname, ftype, fid) = iprot.readFieldBegin()
6572 
      if ftype == TType.STOP:
6573 
        break
6574 
      if fid == 0:
6575 
        if ftype == TType.LIST:
6576 
          self.success = []
7438 amit.gupta 6577 
          (_etype35, _size32) = iprot.readListBegin()
6578 
          for _i36 in xrange(_size32):
6579 
            _elem37 = Item()
6580 
            _elem37.read(iprot)
6581 
            self.success.append(_elem37)
5944 mandeep.dh 6582 
          iprot.readListEnd()
6583 
        else:
6584 
          iprot.skip(ftype)
6585 
      elif fid == 1:
6586 
        if ftype == TType.STRUCT:
6587 
          self.cex = CatalogServiceException()
6588 
          self.cex.read(iprot)
6589 
        else:
6590 
          iprot.skip(ftype)
6591 
      else:
6592 
        iprot.skip(ftype)
6593 
      iprot.readFieldEnd()
6594 
    iprot.readStructEnd()
6595 
 
6596 
  def write(self, oprot):
6597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6599 
      return
6600 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6601 
    if self.success is not None:
6602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6604 
      for iter38 in self.success:
6605 
        iter38.write(oprot)
5944 mandeep.dh 6606 
      oprot.writeListEnd()
6607 
      oprot.writeFieldEnd()
6608 
    if self.cex is not None:
6609 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6610 
      self.cex.write(oprot)
6611 
      oprot.writeFieldEnd()
6612 
    oprot.writeFieldStop()
6613 
    oprot.writeStructEnd()
6614 
 
6615 
  def validate(self):
6616 
    return
6617 
 
6618 
 
6619 
  def __repr__(self):
6620 
    L = ['%s=%r' % (key, value)
6621 
      for key, value in self.__dict__.iteritems()]
6622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6623 
 
6624 
  def __eq__(self, other):
6625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6626 
 
6627 
  def __ne__(self, other):
6628 
    return not (self == other)
6629 
 
6630 
class getValidItemsByCatalogId_args:
6631 
  """
6632 
  Attributes:
6633 
   - catalog_item_id
6634 
  """
6635 
 
6636 
  thrift_spec = (
6637 
    None, # 0
6638 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6639 
  )
6640 
 
6641 
  def __init__(self, catalog_item_id=None,):
6642 
    self.catalog_item_id = catalog_item_id
6643 
 
6644 
  def read(self, iprot):
6645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6647 
      return
6648 
    iprot.readStructBegin()
6649 
    while True:
6650 
      (fname, ftype, fid) = iprot.readFieldBegin()
6651 
      if ftype == TType.STOP:
6652 
        break
6653 
      if fid == 1:
6654 
        if ftype == TType.I64:
6655 
          self.catalog_item_id = iprot.readI64();
6656 
        else:
6657 
          iprot.skip(ftype)
6658 
      else:
6659 
        iprot.skip(ftype)
6660 
      iprot.readFieldEnd()
6661 
    iprot.readStructEnd()
6662 
 
6663 
  def write(self, oprot):
6664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6666 
      return
6667 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6668 
    if self.catalog_item_id is not None:
6669 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6670 
      oprot.writeI64(self.catalog_item_id)
6671 
      oprot.writeFieldEnd()
6672 
    oprot.writeFieldStop()
6673 
    oprot.writeStructEnd()
6674 
 
6675 
  def validate(self):
6676 
    return
6677 
 
6678 
 
6679 
  def __repr__(self):
6680 
    L = ['%s=%r' % (key, value)
6681 
      for key, value in self.__dict__.iteritems()]
6682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6683 
 
6684 
  def __eq__(self, other):
6685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6686 
 
6687 
  def __ne__(self, other):
6688 
    return not (self == other)
6689 
 
6690 
class getValidItemsByCatalogId_result:
6691 
  """
6692 
  Attributes:
6693 
   - success
6694 
   - cex
6695 
  """
6696 
 
6697 
  thrift_spec = (
6698 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6699 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6700 
  )
6701 
 
6702 
  def __init__(self, success=None, cex=None,):
6703 
    self.success = success
6704 
    self.cex = cex
6705 
 
6706 
  def read(self, iprot):
6707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6709 
      return
6710 
    iprot.readStructBegin()
6711 
    while True:
6712 
      (fname, ftype, fid) = iprot.readFieldBegin()
6713 
      if ftype == TType.STOP:
6714 
        break
6715 
      if fid == 0:
6716 
        if ftype == TType.LIST:
6717 
          self.success = []
7438 amit.gupta 6718 
          (_etype42, _size39) = iprot.readListBegin()
6719 
          for _i43 in xrange(_size39):
6720 
            _elem44 = Item()
6721 
            _elem44.read(iprot)
6722 
            self.success.append(_elem44)
5944 mandeep.dh 6723 
          iprot.readListEnd()
6724 
        else:
6725 
          iprot.skip(ftype)
6726 
      elif fid == 1:
6727 
        if ftype == TType.STRUCT:
6728 
          self.cex = CatalogServiceException()
6729 
          self.cex.read(iprot)
6730 
        else:
6731 
          iprot.skip(ftype)
6732 
      else:
6733 
        iprot.skip(ftype)
6734 
      iprot.readFieldEnd()
6735 
    iprot.readStructEnd()
6736 
 
6737 
  def write(self, oprot):
6738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6740 
      return
6741 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6742 
    if self.success is not None:
6743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6745 
      for iter45 in self.success:
6746 
        iter45.write(oprot)
5944 mandeep.dh 6747 
      oprot.writeListEnd()
6748 
      oprot.writeFieldEnd()
6749 
    if self.cex is not None:
6750 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6751 
      self.cex.write(oprot)
6752 
      oprot.writeFieldEnd()
6753 
    oprot.writeFieldStop()
6754 
    oprot.writeStructEnd()
6755 
 
6756 
  def validate(self):
6757 
    return
6758 
 
6759 
 
6760 
  def __repr__(self):
6761 
    L = ['%s=%r' % (key, value)
6762 
      for key, value in self.__dict__.iteritems()]
6763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6764 
 
6765 
  def __eq__(self, other):
6766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6767 
 
6768 
  def __ne__(self, other):
6769 
    return not (self == other)
6770 
 
6771 
class getAllItems_args:
6772 
  """
6773 
  Attributes:
6774 
   - isActive
6775 
  """
6776 
 
6777 
  thrift_spec = (
6778 
    None, # 0
6779 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6780 
  )
6781 
 
6782 
  def __init__(self, isActive=None,):
6783 
    self.isActive = isActive
6784 
 
6785 
  def read(self, iprot):
6786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6788 
      return
6789 
    iprot.readStructBegin()
6790 
    while True:
6791 
      (fname, ftype, fid) = iprot.readFieldBegin()
6792 
      if ftype == TType.STOP:
6793 
        break
6794 
      if fid == 1:
6795 
        if ftype == TType.BOOL:
6796 
          self.isActive = iprot.readBool();
6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      else:
6800 
        iprot.skip(ftype)
6801 
      iprot.readFieldEnd()
6802 
    iprot.readStructEnd()
6803 
 
6804 
  def write(self, oprot):
6805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6807 
      return
6808 
    oprot.writeStructBegin('getAllItems_args')
6809 
    if self.isActive is not None:
6810 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6811 
      oprot.writeBool(self.isActive)
6812 
      oprot.writeFieldEnd()
6813 
    oprot.writeFieldStop()
6814 
    oprot.writeStructEnd()
6815 
 
6816 
  def validate(self):
6817 
    return
6818 
 
6819 
 
6820 
  def __repr__(self):
6821 
    L = ['%s=%r' % (key, value)
6822 
      for key, value in self.__dict__.iteritems()]
6823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6824 
 
6825 
  def __eq__(self, other):
6826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6827 
 
6828 
  def __ne__(self, other):
6829 
    return not (self == other)
6830 
 
6831 
class getAllItems_result:
6832 
  """
6833 
  Attributes:
6834 
   - success
6835 
   - cex
6836 
  """
6837 
 
6838 
  thrift_spec = (
6839 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6840 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6841 
  )
6842 
 
6843 
  def __init__(self, success=None, cex=None,):
6844 
    self.success = success
6845 
    self.cex = cex
6846 
 
6847 
  def read(self, iprot):
6848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6850 
      return
6851 
    iprot.readStructBegin()
6852 
    while True:
6853 
      (fname, ftype, fid) = iprot.readFieldBegin()
6854 
      if ftype == TType.STOP:
6855 
        break
6856 
      if fid == 0:
6857 
        if ftype == TType.LIST:
6858 
          self.success = []
7438 amit.gupta 6859 
          (_etype49, _size46) = iprot.readListBegin()
6860 
          for _i50 in xrange(_size46):
6861 
            _elem51 = Item()
6862 
            _elem51.read(iprot)
6863 
            self.success.append(_elem51)
5944 mandeep.dh 6864 
          iprot.readListEnd()
6865 
        else:
6866 
          iprot.skip(ftype)
6867 
      elif fid == 1:
6868 
        if ftype == TType.STRUCT:
6869 
          self.cex = CatalogServiceException()
6870 
          self.cex.read(iprot)
6871 
        else:
6872 
          iprot.skip(ftype)
6873 
      else:
6874 
        iprot.skip(ftype)
6875 
      iprot.readFieldEnd()
6876 
    iprot.readStructEnd()
6877 
 
6878 
  def write(self, oprot):
6879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6881 
      return
6882 
    oprot.writeStructBegin('getAllItems_result')
6883 
    if self.success is not None:
6884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6886 
      for iter52 in self.success:
6887 
        iter52.write(oprot)
5944 mandeep.dh 6888 
      oprot.writeListEnd()
6889 
      oprot.writeFieldEnd()
6890 
    if self.cex is not None:
6891 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6892 
      self.cex.write(oprot)
6893 
      oprot.writeFieldEnd()
6894 
    oprot.writeFieldStop()
6895 
    oprot.writeStructEnd()
6896 
 
6897 
  def validate(self):
6898 
    return
6899 
 
6900 
 
6901 
  def __repr__(self):
6902 
    L = ['%s=%r' % (key, value)
6903 
      for key, value in self.__dict__.iteritems()]
6904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6905 
 
6906 
  def __eq__(self, other):
6907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6908 
 
6909 
  def __ne__(self, other):
6910 
    return not (self == other)
6911 
 
6912 
class getAllItemsByStatus_args:
6913 
  """
6914 
  Attributes:
6915 
   - itemStatus
6916 
  """
6917 
 
6918 
  thrift_spec = (
6919 
    None, # 0
6920 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6921 
  )
6922 
 
6923 
  def __init__(self, itemStatus=None,):
6924 
    self.itemStatus = itemStatus
6925 
 
6926 
  def read(self, iprot):
6927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6929 
      return
6930 
    iprot.readStructBegin()
6931 
    while True:
6932 
      (fname, ftype, fid) = iprot.readFieldBegin()
6933 
      if ftype == TType.STOP:
6934 
        break
6935 
      if fid == 1:
6936 
        if ftype == TType.I32:
6937 
          self.itemStatus = iprot.readI32();
6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      else:
6941 
        iprot.skip(ftype)
6942 
      iprot.readFieldEnd()
6943 
    iprot.readStructEnd()
6944 
 
6945 
  def write(self, oprot):
6946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6948 
      return
6949 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6950 
    if self.itemStatus is not None:
6951 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6952 
      oprot.writeI32(self.itemStatus)
6953 
      oprot.writeFieldEnd()
6954 
    oprot.writeFieldStop()
6955 
    oprot.writeStructEnd()
6956 
 
6957 
  def validate(self):
6958 
    return
6959 
 
6960 
 
6961 
  def __repr__(self):
6962 
    L = ['%s=%r' % (key, value)
6963 
      for key, value in self.__dict__.iteritems()]
6964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6965 
 
6966 
  def __eq__(self, other):
6967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6968 
 
6969 
  def __ne__(self, other):
6970 
    return not (self == other)
6971 
 
6972 
class getAllItemsByStatus_result:
6973 
  """
6974 
  Attributes:
6975 
   - success
6976 
   - cex
6977 
  """
6978 
 
6979 
  thrift_spec = (
6980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6981 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6982 
  )
6983 
 
6984 
  def __init__(self, success=None, cex=None,):
6985 
    self.success = success
6986 
    self.cex = cex
6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 0:
6998 
        if ftype == TType.LIST:
6999 
          self.success = []
7438 amit.gupta 7000 
          (_etype56, _size53) = iprot.readListBegin()
7001 
          for _i57 in xrange(_size53):
7002 
            _elem58 = Item()
7003 
            _elem58.read(iprot)
7004 
            self.success.append(_elem58)
5944 mandeep.dh 7005 
          iprot.readListEnd()
7006 
        else:
7007 
          iprot.skip(ftype)
7008 
      elif fid == 1:
7009 
        if ftype == TType.STRUCT:
7010 
          self.cex = CatalogServiceException()
7011 
          self.cex.read(iprot)
7012 
        else:
7013 
          iprot.skip(ftype)
7014 
      else:
7015 
        iprot.skip(ftype)
7016 
      iprot.readFieldEnd()
7017 
    iprot.readStructEnd()
7018 
 
7019 
  def write(self, oprot):
7020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7022 
      return
7023 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7024 
    if self.success is not None:
7025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7027 
      for iter59 in self.success:
7028 
        iter59.write(oprot)
5944 mandeep.dh 7029 
      oprot.writeListEnd()
7030 
      oprot.writeFieldEnd()
7031 
    if self.cex is not None:
7032 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7033 
      self.cex.write(oprot)
7034 
      oprot.writeFieldEnd()
7035 
    oprot.writeFieldStop()
7036 
    oprot.writeStructEnd()
7037 
 
7038 
  def validate(self):
7039 
    return
7040 
 
7041 
 
7042 
  def __repr__(self):
7043 
    L = ['%s=%r' % (key, value)
7044 
      for key, value in self.__dict__.iteritems()]
7045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7046 
 
7047 
  def __eq__(self, other):
7048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7049 
 
7050 
  def __ne__(self, other):
7051 
    return not (self == other)
7052 
 
7053 
class markItemAsContentComplete_args:
7054 
  """
7055 
  Attributes:
7056 
   - entityId
7057 
   - category
7058 
   - brand
7059 
   - modelName
7060 
   - modelNumber
7061 
  """
7062 
 
7063 
  thrift_spec = (
7064 
    None, # 0
7065 
    (1, TType.I64, 'entityId', None, None, ), # 1
7066 
    (2, TType.I64, 'category', None, None, ), # 2
7067 
    (3, TType.STRING, 'brand', None, None, ), # 3
7068 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7069 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7070 
  )
7071 
 
7072 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7073 
    self.entityId = entityId
7074 
    self.category = category
7075 
    self.brand = brand
7076 
    self.modelName = modelName
7077 
    self.modelNumber = modelNumber
7078 
 
7079 
  def read(self, iprot):
7080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7082 
      return
7083 
    iprot.readStructBegin()
7084 
    while True:
7085 
      (fname, ftype, fid) = iprot.readFieldBegin()
7086 
      if ftype == TType.STOP:
7087 
        break
7088 
      if fid == 1:
7089 
        if ftype == TType.I64:
7090 
          self.entityId = iprot.readI64();
7091 
        else:
7092 
          iprot.skip(ftype)
7093 
      elif fid == 2:
7094 
        if ftype == TType.I64:
7095 
          self.category = iprot.readI64();
7096 
        else:
7097 
          iprot.skip(ftype)
7098 
      elif fid == 3:
7099 
        if ftype == TType.STRING:
7100 
          self.brand = iprot.readString();
7101 
        else:
7102 
          iprot.skip(ftype)
7103 
      elif fid == 4:
7104 
        if ftype == TType.STRING:
7105 
          self.modelName = iprot.readString();
7106 
        else:
7107 
          iprot.skip(ftype)
7108 
      elif fid == 5:
7109 
        if ftype == TType.STRING:
7110 
          self.modelNumber = iprot.readString();
7111 
        else:
7112 
          iprot.skip(ftype)
7113 
      else:
7114 
        iprot.skip(ftype)
7115 
      iprot.readFieldEnd()
7116 
    iprot.readStructEnd()
7117 
 
7118 
  def write(self, oprot):
7119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7121 
      return
7122 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7123 
    if self.entityId is not None:
7124 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7125 
      oprot.writeI64(self.entityId)
7126 
      oprot.writeFieldEnd()
7127 
    if self.category is not None:
7128 
      oprot.writeFieldBegin('category', TType.I64, 2)
7129 
      oprot.writeI64(self.category)
7130 
      oprot.writeFieldEnd()
7131 
    if self.brand is not None:
7132 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7133 
      oprot.writeString(self.brand)
7134 
      oprot.writeFieldEnd()
7135 
    if self.modelName is not None:
7136 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7137 
      oprot.writeString(self.modelName)
7138 
      oprot.writeFieldEnd()
7139 
    if self.modelNumber is not None:
7140 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7141 
      oprot.writeString(self.modelNumber)
7142 
      oprot.writeFieldEnd()
7143 
    oprot.writeFieldStop()
7144 
    oprot.writeStructEnd()
7145 
 
7146 
  def validate(self):
7147 
    return
7148 
 
7149 
 
7150 
  def __repr__(self):
7151 
    L = ['%s=%r' % (key, value)
7152 
      for key, value in self.__dict__.iteritems()]
7153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7154 
 
7155 
  def __eq__(self, other):
7156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7157 
 
7158 
  def __ne__(self, other):
7159 
    return not (self == other)
7160 
 
7161 
class markItemAsContentComplete_result:
7162 
  """
7163 
  Attributes:
7164 
   - success
7165 
   - cex
7166 
  """
7167 
 
7168 
  thrift_spec = (
7169 
    (0, TType.BOOL, 'success', None, None, ), # 0
7170 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7171 
  )
7172 
 
7173 
  def __init__(self, success=None, cex=None,):
7174 
    self.success = success
7175 
    self.cex = cex
7176 
 
7177 
  def read(self, iprot):
7178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7180 
      return
7181 
    iprot.readStructBegin()
7182 
    while True:
7183 
      (fname, ftype, fid) = iprot.readFieldBegin()
7184 
      if ftype == TType.STOP:
7185 
        break
7186 
      if fid == 0:
7187 
        if ftype == TType.BOOL:
7188 
          self.success = iprot.readBool();
7189 
        else:
7190 
          iprot.skip(ftype)
7191 
      elif fid == 1:
7192 
        if ftype == TType.STRUCT:
7193 
          self.cex = CatalogServiceException()
7194 
          self.cex.read(iprot)
7195 
        else:
7196 
          iprot.skip(ftype)
7197 
      else:
7198 
        iprot.skip(ftype)
7199 
      iprot.readFieldEnd()
7200 
    iprot.readStructEnd()
7201 
 
7202 
  def write(self, oprot):
7203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7205 
      return
7206 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7207 
    if self.success is not None:
7208 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7209 
      oprot.writeBool(self.success)
7210 
      oprot.writeFieldEnd()
7211 
    if self.cex is not None:
7212 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7213 
      self.cex.write(oprot)
7214 
      oprot.writeFieldEnd()
7215 
    oprot.writeFieldStop()
7216 
    oprot.writeStructEnd()
7217 
 
7218 
  def validate(self):
7219 
    return
7220 
 
7221 
 
7222 
  def __repr__(self):
7223 
    L = ['%s=%r' % (key, value)
7224 
      for key, value in self.__dict__.iteritems()]
7225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7226 
 
7227 
  def __eq__(self, other):
7228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7229 
 
7230 
  def __ne__(self, other):
7231 
    return not (self == other)
7232 
 
7233 
class getAllItemsInRange_args:
7234 
  """
7235 
  Attributes:
7236 
   - offset
7237 
   - limit
7238 
  """
7239 
 
7240 
  thrift_spec = (
7241 
    None, # 0
7242 
    (1, TType.I64, 'offset', None, None, ), # 1
7243 
    (2, TType.I64, 'limit', None, None, ), # 2
7244 
  )
7245 
 
7246 
  def __init__(self, offset=None, limit=None,):
7247 
    self.offset = offset
7248 
    self.limit = limit
7249 
 
7250 
  def read(self, iprot):
7251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7253 
      return
7254 
    iprot.readStructBegin()
7255 
    while True:
7256 
      (fname, ftype, fid) = iprot.readFieldBegin()
7257 
      if ftype == TType.STOP:
7258 
        break
7259 
      if fid == 1:
7260 
        if ftype == TType.I64:
7261 
          self.offset = iprot.readI64();
7262 
        else:
7263 
          iprot.skip(ftype)
7264 
      elif fid == 2:
7265 
        if ftype == TType.I64:
7266 
          self.limit = iprot.readI64();
7267 
        else:
7268 
          iprot.skip(ftype)
7269 
      else:
7270 
        iprot.skip(ftype)
7271 
      iprot.readFieldEnd()
7272 
    iprot.readStructEnd()
7273 
 
7274 
  def write(self, oprot):
7275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7277 
      return
7278 
    oprot.writeStructBegin('getAllItemsInRange_args')
7279 
    if self.offset is not None:
7280 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7281 
      oprot.writeI64(self.offset)
7282 
      oprot.writeFieldEnd()
7283 
    if self.limit is not None:
7284 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7285 
      oprot.writeI64(self.limit)
7286 
      oprot.writeFieldEnd()
7287 
    oprot.writeFieldStop()
7288 
    oprot.writeStructEnd()
7289 
 
7290 
  def validate(self):
7291 
    return
7292 
 
7293 
 
7294 
  def __repr__(self):
7295 
    L = ['%s=%r' % (key, value)
7296 
      for key, value in self.__dict__.iteritems()]
7297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7298 
 
7299 
  def __eq__(self, other):
7300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7301 
 
7302 
  def __ne__(self, other):
7303 
    return not (self == other)
7304 
 
7305 
class getAllItemsInRange_result:
7306 
  """
7307 
  Attributes:
7308 
   - success
7309 
   - cex
7310 
  """
7311 
 
7312 
  thrift_spec = (
7313 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7314 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7315 
  )
7316 
 
7317 
  def __init__(self, success=None, cex=None,):
7318 
    self.success = success
7319 
    self.cex = cex
7320 
 
7321 
  def read(self, iprot):
7322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7324 
      return
7325 
    iprot.readStructBegin()
7326 
    while True:
7327 
      (fname, ftype, fid) = iprot.readFieldBegin()
7328 
      if ftype == TType.STOP:
7329 
        break
7330 
      if fid == 0:
7331 
        if ftype == TType.LIST:
7332 
          self.success = []
7438 amit.gupta 7333 
          (_etype63, _size60) = iprot.readListBegin()
7334 
          for _i64 in xrange(_size60):
7335 
            _elem65 = Item()
7336 
            _elem65.read(iprot)
7337 
            self.success.append(_elem65)
5944 mandeep.dh 7338 
          iprot.readListEnd()
7339 
        else:
7340 
          iprot.skip(ftype)
7341 
      elif fid == 1:
7342 
        if ftype == TType.STRUCT:
7343 
          self.cex = CatalogServiceException()
7344 
          self.cex.read(iprot)
7345 
        else:
7346 
          iprot.skip(ftype)
7347 
      else:
7348 
        iprot.skip(ftype)
7349 
      iprot.readFieldEnd()
7350 
    iprot.readStructEnd()
7351 
 
7352 
  def write(self, oprot):
7353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7355 
      return
7356 
    oprot.writeStructBegin('getAllItemsInRange_result')
7357 
    if self.success is not None:
7358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7360 
      for iter66 in self.success:
7361 
        iter66.write(oprot)
5944 mandeep.dh 7362 
      oprot.writeListEnd()
7363 
      oprot.writeFieldEnd()
7364 
    if self.cex is not None:
7365 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7366 
      self.cex.write(oprot)
7367 
      oprot.writeFieldEnd()
7368 
    oprot.writeFieldStop()
7369 
    oprot.writeStructEnd()
7370 
 
7371 
  def validate(self):
7372 
    return
7373 
 
7374 
 
7375 
  def __repr__(self):
7376 
    L = ['%s=%r' % (key, value)
7377 
      for key, value in self.__dict__.iteritems()]
7378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7379 
 
7380 
  def __eq__(self, other):
7381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7382 
 
7383 
  def __ne__(self, other):
7384 
    return not (self == other)
7385 
 
7386 
class getAllItemsByStatusInRange_args:
7387 
  """
7388 
  Attributes:
7389 
   - itemStatus
7390 
   - offset
7391 
   - limit
7392 
  """
7393 
 
7394 
  thrift_spec = (
7395 
    None, # 0
7396 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7397 
    (2, TType.I64, 'offset', None, None, ), # 2
7398 
    (3, TType.I64, 'limit', None, None, ), # 3
7399 
  )
7400 
 
7401 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7402 
    self.itemStatus = itemStatus
7403 
    self.offset = offset
7404 
    self.limit = limit
7405 
 
7406 
  def read(self, iprot):
7407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7409 
      return
7410 
    iprot.readStructBegin()
7411 
    while True:
7412 
      (fname, ftype, fid) = iprot.readFieldBegin()
7413 
      if ftype == TType.STOP:
7414 
        break
7415 
      if fid == 1:
7416 
        if ftype == TType.I32:
7417 
          self.itemStatus = iprot.readI32();
7418 
        else:
7419 
          iprot.skip(ftype)
7420 
      elif fid == 2:
7421 
        if ftype == TType.I64:
7422 
          self.offset = iprot.readI64();
7423 
        else:
7424 
          iprot.skip(ftype)
7425 
      elif fid == 3:
7426 
        if ftype == TType.I64:
7427 
          self.limit = iprot.readI64();
7428 
        else:
7429 
          iprot.skip(ftype)
7430 
      else:
7431 
        iprot.skip(ftype)
7432 
      iprot.readFieldEnd()
7433 
    iprot.readStructEnd()
7434 
 
7435 
  def write(self, oprot):
7436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7438 
      return
7439 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7440 
    if self.itemStatus is not None:
7441 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7442 
      oprot.writeI32(self.itemStatus)
7443 
      oprot.writeFieldEnd()
7444 
    if self.offset is not None:
7445 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7446 
      oprot.writeI64(self.offset)
7447 
      oprot.writeFieldEnd()
7448 
    if self.limit is not None:
7449 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7450 
      oprot.writeI64(self.limit)
7451 
      oprot.writeFieldEnd()
7452 
    oprot.writeFieldStop()
7453 
    oprot.writeStructEnd()
7454 
 
7455 
  def validate(self):
7456 
    return
7457 
 
7458 
 
7459 
  def __repr__(self):
7460 
    L = ['%s=%r' % (key, value)
7461 
      for key, value in self.__dict__.iteritems()]
7462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7463 
 
7464 
  def __eq__(self, other):
7465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7466 
 
7467 
  def __ne__(self, other):
7468 
    return not (self == other)
7469 
 
7470 
class getAllItemsByStatusInRange_result:
7471 
  """
7472 
  Attributes:
7473 
   - success
7474 
   - cex
7475 
  """
7476 
 
7477 
  thrift_spec = (
7478 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7479 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7480 
  )
7481 
 
7482 
  def __init__(self, success=None, cex=None,):
7483 
    self.success = success
7484 
    self.cex = cex
7485 
 
7486 
  def read(self, iprot):
7487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7489 
      return
7490 
    iprot.readStructBegin()
7491 
    while True:
7492 
      (fname, ftype, fid) = iprot.readFieldBegin()
7493 
      if ftype == TType.STOP:
7494 
        break
7495 
      if fid == 0:
7496 
        if ftype == TType.LIST:
7497 
          self.success = []
7438 amit.gupta 7498 
          (_etype70, _size67) = iprot.readListBegin()
7499 
          for _i71 in xrange(_size67):
7500 
            _elem72 = Item()
7501 
            _elem72.read(iprot)
7502 
            self.success.append(_elem72)
5944 mandeep.dh 7503 
          iprot.readListEnd()
7504 
        else:
7505 
          iprot.skip(ftype)
7506 
      elif fid == 1:
7507 
        if ftype == TType.STRUCT:
7508 
          self.cex = CatalogServiceException()
7509 
          self.cex.read(iprot)
7510 
        else:
7511 
          iprot.skip(ftype)
7512 
      else:
7513 
        iprot.skip(ftype)
7514 
      iprot.readFieldEnd()
7515 
    iprot.readStructEnd()
7516 
 
7517 
  def write(self, oprot):
7518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7520 
      return
7521 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7522 
    if self.success is not None:
7523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7524 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7525 
      for iter73 in self.success:
7526 
        iter73.write(oprot)
5944 mandeep.dh 7527 
      oprot.writeListEnd()
7528 
      oprot.writeFieldEnd()
7529 
    if self.cex is not None:
7530 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7531 
      self.cex.write(oprot)
7532 
      oprot.writeFieldEnd()
7533 
    oprot.writeFieldStop()
7534 
    oprot.writeStructEnd()
7535 
 
7536 
  def validate(self):
7537 
    return
7538 
 
7539 
 
7540 
  def __repr__(self):
7541 
    L = ['%s=%r' % (key, value)
7542 
      for key, value in self.__dict__.iteritems()]
7543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7544 
 
7545 
  def __eq__(self, other):
7546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7547 
 
7548 
  def __ne__(self, other):
7549 
    return not (self == other)
7550 
 
7551 
class getItemCountByStatus_args:
7552 
  """
7553 
  Attributes:
7554 
   - useStatus
7555 
   - itemStatus
7556 
  """
7557 
 
7558 
  thrift_spec = (
7559 
    None, # 0
7560 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7561 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7562 
  )
7563 
 
7564 
  def __init__(self, useStatus=None, itemStatus=None,):
7565 
    self.useStatus = useStatus
7566 
    self.itemStatus = itemStatus
7567 
 
7568 
  def read(self, iprot):
7569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7571 
      return
7572 
    iprot.readStructBegin()
7573 
    while True:
7574 
      (fname, ftype, fid) = iprot.readFieldBegin()
7575 
      if ftype == TType.STOP:
7576 
        break
7577 
      if fid == 1:
7578 
        if ftype == TType.BOOL:
7579 
          self.useStatus = iprot.readBool();
7580 
        else:
7581 
          iprot.skip(ftype)
7582 
      elif fid == 2:
7583 
        if ftype == TType.I32:
7584 
          self.itemStatus = iprot.readI32();
7585 
        else:
7586 
          iprot.skip(ftype)
7587 
      else:
7588 
        iprot.skip(ftype)
7589 
      iprot.readFieldEnd()
7590 
    iprot.readStructEnd()
7591 
 
7592 
  def write(self, oprot):
7593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7595 
      return
7596 
    oprot.writeStructBegin('getItemCountByStatus_args')
7597 
    if self.useStatus is not None:
7598 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7599 
      oprot.writeBool(self.useStatus)
7600 
      oprot.writeFieldEnd()
7601 
    if self.itemStatus is not None:
7602 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7603 
      oprot.writeI32(self.itemStatus)
7604 
      oprot.writeFieldEnd()
7605 
    oprot.writeFieldStop()
7606 
    oprot.writeStructEnd()
7607 
 
7608 
  def validate(self):
7609 
    return
7610 
 
7611 
 
7612 
  def __repr__(self):
7613 
    L = ['%s=%r' % (key, value)
7614 
      for key, value in self.__dict__.iteritems()]
7615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7616 
 
7617 
  def __eq__(self, other):
7618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7619 
 
7620 
  def __ne__(self, other):
7621 
    return not (self == other)
7622 
 
7623 
class getItemCountByStatus_result:
7624 
  """
7625 
  Attributes:
7626 
   - success
7627 
  """
7628 
 
7629 
  thrift_spec = (
7630 
    (0, TType.I32, 'success', None, None, ), # 0
7631 
  )
7632 
 
7633 
  def __init__(self, success=None,):
7634 
    self.success = success
7635 
 
7636 
  def read(self, iprot):
7637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7639 
      return
7640 
    iprot.readStructBegin()
7641 
    while True:
7642 
      (fname, ftype, fid) = iprot.readFieldBegin()
7643 
      if ftype == TType.STOP:
7644 
        break
7645 
      if fid == 0:
7646 
        if ftype == TType.I32:
7647 
          self.success = iprot.readI32();
7648 
        else:
7649 
          iprot.skip(ftype)
7650 
      else:
7651 
        iprot.skip(ftype)
7652 
      iprot.readFieldEnd()
7653 
    iprot.readStructEnd()
7654 
 
7655 
  def write(self, oprot):
7656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7658 
      return
7659 
    oprot.writeStructBegin('getItemCountByStatus_result')
7660 
    if self.success is not None:
7661 
      oprot.writeFieldBegin('success', TType.I32, 0)
7662 
      oprot.writeI32(self.success)
7663 
      oprot.writeFieldEnd()
7664 
    oprot.writeFieldStop()
7665 
    oprot.writeStructEnd()
7666 
 
7667 
  def validate(self):
7668 
    return
7669 
 
7670 
 
7671 
  def __repr__(self):
7672 
    L = ['%s=%r' % (key, value)
7673 
      for key, value in self.__dict__.iteritems()]
7674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7675 
 
7676 
  def __eq__(self, other):
7677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7678 
 
7679 
  def __ne__(self, other):
7680 
    return not (self == other)
7681 
 
7682 
class getBestSellers_args:
7683 
 
7684 
  thrift_spec = (
7685 
  )
7686 
 
7687 
  def read(self, iprot):
7688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7690 
      return
7691 
    iprot.readStructBegin()
7692 
    while True:
7693 
      (fname, ftype, fid) = iprot.readFieldBegin()
7694 
      if ftype == TType.STOP:
7695 
        break
7696 
      else:
7697 
        iprot.skip(ftype)
7698 
      iprot.readFieldEnd()
7699 
    iprot.readStructEnd()
7700 
 
7701 
  def write(self, oprot):
7702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7704 
      return
7705 
    oprot.writeStructBegin('getBestSellers_args')
7706 
    oprot.writeFieldStop()
7707 
    oprot.writeStructEnd()
7708 
 
7709 
  def validate(self):
7710 
    return
7711 
 
7712 
 
7713 
  def __repr__(self):
7714 
    L = ['%s=%r' % (key, value)
7715 
      for key, value in self.__dict__.iteritems()]
7716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7717 
 
7718 
  def __eq__(self, other):
7719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7720 
 
7721 
  def __ne__(self, other):
7722 
    return not (self == other)
7723 
 
7724 
class getBestSellers_result:
7725 
  """
7726 
  Attributes:
7727 
   - success
7728 
   - isex
7729 
  """
7730 
 
7731 
  thrift_spec = (
7732 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7733 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7734 
  )
7735 
 
7736 
  def __init__(self, success=None, isex=None,):
7737 
    self.success = success
7738 
    self.isex = isex
7739 
 
7740 
  def read(self, iprot):
7741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7743 
      return
7744 
    iprot.readStructBegin()
7745 
    while True:
7746 
      (fname, ftype, fid) = iprot.readFieldBegin()
7747 
      if ftype == TType.STOP:
7748 
        break
7749 
      if fid == 0:
7750 
        if ftype == TType.LIST:
7751 
          self.success = []
7438 amit.gupta 7752 
          (_etype77, _size74) = iprot.readListBegin()
7753 
          for _i78 in xrange(_size74):
7754 
            _elem79 = Item()
7755 
            _elem79.read(iprot)
7756 
            self.success.append(_elem79)
5944 mandeep.dh 7757 
          iprot.readListEnd()
7758 
        else:
7759 
          iprot.skip(ftype)
7760 
      elif fid == 1:
7761 
        if ftype == TType.STRUCT:
7762 
          self.isex = CatalogServiceException()
7763 
          self.isex.read(iprot)
7764 
        else:
7765 
          iprot.skip(ftype)
7766 
      else:
7767 
        iprot.skip(ftype)
7768 
      iprot.readFieldEnd()
7769 
    iprot.readStructEnd()
7770 
 
7771 
  def write(self, oprot):
7772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7774 
      return
7775 
    oprot.writeStructBegin('getBestSellers_result')
7776 
    if self.success is not None:
7777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7779 
      for iter80 in self.success:
7780 
        iter80.write(oprot)
5944 mandeep.dh 7781 
      oprot.writeListEnd()
7782 
      oprot.writeFieldEnd()
7783 
    if self.isex is not None:
7784 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7785 
      self.isex.write(oprot)
7786 
      oprot.writeFieldEnd()
7787 
    oprot.writeFieldStop()
7788 
    oprot.writeStructEnd()
7789 
 
7790 
  def validate(self):
7791 
    return
7792 
 
7793 
 
7794 
  def __repr__(self):
7795 
    L = ['%s=%r' % (key, value)
7796 
      for key, value in self.__dict__.iteritems()]
7797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7798 
 
7799 
  def __eq__(self, other):
7800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7801 
 
7802 
  def __ne__(self, other):
7803 
    return not (self == other)
7804 
 
7805 
class getBestSellersCatalogIds_args:
7806 
  """
7807 
  Attributes:
7808 
   - beginIndex
7809 
   - totalItems
7810 
   - brand
7811 
   - category
7812 
  """
7813 
 
7814 
  thrift_spec = (
7815 
    None, # 0
7816 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7817 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7818 
    (3, TType.STRING, 'brand', None, None, ), # 3
7819 
    (4, TType.I64, 'category', None, None, ), # 4
7820 
  )
7821 
 
7822 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7823 
    self.beginIndex = beginIndex
7824 
    self.totalItems = totalItems
7825 
    self.brand = brand
7826 
    self.category = category
7827 
 
7828 
  def read(self, iprot):
7829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7831 
      return
7832 
    iprot.readStructBegin()
7833 
    while True:
7834 
      (fname, ftype, fid) = iprot.readFieldBegin()
7835 
      if ftype == TType.STOP:
7836 
        break
7837 
      if fid == 1:
7838 
        if ftype == TType.I64:
7839 
          self.beginIndex = iprot.readI64();
7840 
        else:
7841 
          iprot.skip(ftype)
7842 
      elif fid == 2:
7843 
        if ftype == TType.I64:
7844 
          self.totalItems = iprot.readI64();
7845 
        else:
7846 
          iprot.skip(ftype)
7847 
      elif fid == 3:
7848 
        if ftype == TType.STRING:
7849 
          self.brand = iprot.readString();
7850 
        else:
7851 
          iprot.skip(ftype)
7852 
      elif fid == 4:
7853 
        if ftype == TType.I64:
7854 
          self.category = iprot.readI64();
7855 
        else:
7856 
          iprot.skip(ftype)
7857 
      else:
7858 
        iprot.skip(ftype)
7859 
      iprot.readFieldEnd()
7860 
    iprot.readStructEnd()
7861 
 
7862 
  def write(self, oprot):
7863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7865 
      return
7866 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7867 
    if self.beginIndex is not None:
7868 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7869 
      oprot.writeI64(self.beginIndex)
7870 
      oprot.writeFieldEnd()
7871 
    if self.totalItems is not None:
7872 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7873 
      oprot.writeI64(self.totalItems)
7874 
      oprot.writeFieldEnd()
7875 
    if self.brand is not None:
7876 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7877 
      oprot.writeString(self.brand)
7878 
      oprot.writeFieldEnd()
7879 
    if self.category is not None:
7880 
      oprot.writeFieldBegin('category', TType.I64, 4)
7881 
      oprot.writeI64(self.category)
7882 
      oprot.writeFieldEnd()
7883 
    oprot.writeFieldStop()
7884 
    oprot.writeStructEnd()
7885 
 
7886 
  def validate(self):
7887 
    return
7888 
 
7889 
 
7890 
  def __repr__(self):
7891 
    L = ['%s=%r' % (key, value)
7892 
      for key, value in self.__dict__.iteritems()]
7893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7894 
 
7895 
  def __eq__(self, other):
7896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7897 
 
7898 
  def __ne__(self, other):
7899 
    return not (self == other)
7900 
 
7901 
class getBestSellersCatalogIds_result:
7902 
  """
7903 
  Attributes:
7904 
   - success
7905 
   - cex
7906 
  """
7907 
 
7908 
  thrift_spec = (
7909 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7910 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7911 
  )
7912 
 
7913 
  def __init__(self, success=None, cex=None,):
7914 
    self.success = success
7915 
    self.cex = cex
7916 
 
7917 
  def read(self, iprot):
7918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7920 
      return
7921 
    iprot.readStructBegin()
7922 
    while True:
7923 
      (fname, ftype, fid) = iprot.readFieldBegin()
7924 
      if ftype == TType.STOP:
7925 
        break
7926 
      if fid == 0:
7927 
        if ftype == TType.LIST:
7928 
          self.success = []
7438 amit.gupta 7929 
          (_etype84, _size81) = iprot.readListBegin()
7930 
          for _i85 in xrange(_size81):
7931 
            _elem86 = iprot.readI64();
7932 
            self.success.append(_elem86)
5944 mandeep.dh 7933 
          iprot.readListEnd()
7934 
        else:
7935 
          iprot.skip(ftype)
7936 
      elif fid == 1:
7937 
        if ftype == TType.STRUCT:
7938 
          self.cex = CatalogServiceException()
7939 
          self.cex.read(iprot)
7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
7951 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7952 
    if self.success is not None:
7953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7954 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 7955 
      for iter87 in self.success:
7956 
        oprot.writeI64(iter87)
5944 mandeep.dh 7957 
      oprot.writeListEnd()
7958 
      oprot.writeFieldEnd()
7959 
    if self.cex is not None:
7960 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7961 
      self.cex.write(oprot)
7962 
      oprot.writeFieldEnd()
7963 
    oprot.writeFieldStop()
7964 
    oprot.writeStructEnd()
7965 
 
7966 
  def validate(self):
7967 
    return
7968 
 
7969 
 
7970 
  def __repr__(self):
7971 
    L = ['%s=%r' % (key, value)
7972 
      for key, value in self.__dict__.iteritems()]
7973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7974 
 
7975 
  def __eq__(self, other):
7976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7977 
 
7978 
  def __ne__(self, other):
7979 
    return not (self == other)
7980 
 
7981 
class getBestSellersCount_args:
7982 
 
7983 
  thrift_spec = (
7984 
  )
7985 
 
7986 
  def read(self, iprot):
7987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7989 
      return
7990 
    iprot.readStructBegin()
7991 
    while True:
7992 
      (fname, ftype, fid) = iprot.readFieldBegin()
7993 
      if ftype == TType.STOP:
7994 
        break
7995 
      else:
7996 
        iprot.skip(ftype)
7997 
      iprot.readFieldEnd()
7998 
    iprot.readStructEnd()
7999 
 
8000 
  def write(self, oprot):
8001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8003 
      return
8004 
    oprot.writeStructBegin('getBestSellersCount_args')
8005 
    oprot.writeFieldStop()
8006 
    oprot.writeStructEnd()
8007 
 
8008 
  def validate(self):
8009 
    return
8010 
 
8011 
 
8012 
  def __repr__(self):
8013 
    L = ['%s=%r' % (key, value)
8014 
      for key, value in self.__dict__.iteritems()]
8015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8016 
 
8017 
  def __eq__(self, other):
8018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8019 
 
8020 
  def __ne__(self, other):
8021 
    return not (self == other)
8022 
 
8023 
class getBestSellersCount_result:
8024 
  """
8025 
  Attributes:
8026 
   - success
8027 
   - cex
8028 
  """
8029 
 
8030 
  thrift_spec = (
8031 
    (0, TType.I64, 'success', None, None, ), # 0
8032 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8033 
  )
8034 
 
8035 
  def __init__(self, success=None, cex=None,):
8036 
    self.success = success
8037 
    self.cex = cex
8038 
 
8039 
  def read(self, iprot):
8040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8042 
      return
8043 
    iprot.readStructBegin()
8044 
    while True:
8045 
      (fname, ftype, fid) = iprot.readFieldBegin()
8046 
      if ftype == TType.STOP:
8047 
        break
8048 
      if fid == 0:
8049 
        if ftype == TType.I64:
8050 
          self.success = iprot.readI64();
8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      elif fid == 1:
8054 
        if ftype == TType.STRUCT:
8055 
          self.cex = CatalogServiceException()
8056 
          self.cex.read(iprot)
8057 
        else:
8058 
          iprot.skip(ftype)
8059 
      else:
8060 
        iprot.skip(ftype)
8061 
      iprot.readFieldEnd()
8062 
    iprot.readStructEnd()
8063 
 
8064 
  def write(self, oprot):
8065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8067 
      return
8068 
    oprot.writeStructBegin('getBestSellersCount_result')
8069 
    if self.success is not None:
8070 
      oprot.writeFieldBegin('success', TType.I64, 0)
8071 
      oprot.writeI64(self.success)
8072 
      oprot.writeFieldEnd()
8073 
    if self.cex is not None:
8074 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8075 
      self.cex.write(oprot)
8076 
      oprot.writeFieldEnd()
8077 
    oprot.writeFieldStop()
8078 
    oprot.writeStructEnd()
8079 
 
8080 
  def validate(self):
8081 
    return
8082 
 
8083 
 
8084 
  def __repr__(self):
8085 
    L = ['%s=%r' % (key, value)
8086 
      for key, value in self.__dict__.iteritems()]
8087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8088 
 
8089 
  def __eq__(self, other):
8090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8091 
 
8092 
  def __ne__(self, other):
8093 
    return not (self == other)
8094 
 
8095 
class getBestDeals_args:
8096 
 
8097 
  thrift_spec = (
8098 
  )
8099 
 
8100 
  def read(self, iprot):
8101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8103 
      return
8104 
    iprot.readStructBegin()
8105 
    while True:
8106 
      (fname, ftype, fid) = iprot.readFieldBegin()
8107 
      if ftype == TType.STOP:
8108 
        break
8109 
      else:
8110 
        iprot.skip(ftype)
8111 
      iprot.readFieldEnd()
8112 
    iprot.readStructEnd()
8113 
 
8114 
  def write(self, oprot):
8115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8117 
      return
8118 
    oprot.writeStructBegin('getBestDeals_args')
8119 
    oprot.writeFieldStop()
8120 
    oprot.writeStructEnd()
8121 
 
8122 
  def validate(self):
8123 
    return
8124 
 
8125 
 
8126 
  def __repr__(self):
8127 
    L = ['%s=%r' % (key, value)
8128 
      for key, value in self.__dict__.iteritems()]
8129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8130 
 
8131 
  def __eq__(self, other):
8132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8133 
 
8134 
  def __ne__(self, other):
8135 
    return not (self == other)
8136 
 
8137 
class getBestDeals_result:
8138 
  """
8139 
  Attributes:
8140 
   - success
8141 
   - isex
8142 
  """
8143 
 
8144 
  thrift_spec = (
8145 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8146 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8147 
  )
8148 
 
8149 
  def __init__(self, success=None, isex=None,):
8150 
    self.success = success
8151 
    self.isex = isex
8152 
 
8153 
  def read(self, iprot):
8154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8156 
      return
8157 
    iprot.readStructBegin()
8158 
    while True:
8159 
      (fname, ftype, fid) = iprot.readFieldBegin()
8160 
      if ftype == TType.STOP:
8161 
        break
8162 
      if fid == 0:
8163 
        if ftype == TType.LIST:
8164 
          self.success = []
7438 amit.gupta 8165 
          (_etype91, _size88) = iprot.readListBegin()
8166 
          for _i92 in xrange(_size88):
8167 
            _elem93 = Item()
8168 
            _elem93.read(iprot)
8169 
            self.success.append(_elem93)
5944 mandeep.dh 8170 
          iprot.readListEnd()
8171 
        else:
8172 
          iprot.skip(ftype)
8173 
      elif fid == 1:
8174 
        if ftype == TType.STRUCT:
8175 
          self.isex = CatalogServiceException()
8176 
          self.isex.read(iprot)
8177 
        else:
8178 
          iprot.skip(ftype)
8179 
      else:
8180 
        iprot.skip(ftype)
8181 
      iprot.readFieldEnd()
8182 
    iprot.readStructEnd()
8183 
 
8184 
  def write(self, oprot):
8185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8187 
      return
8188 
    oprot.writeStructBegin('getBestDeals_result')
8189 
    if self.success is not None:
8190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8192 
      for iter94 in self.success:
8193 
        iter94.write(oprot)
5944 mandeep.dh 8194 
      oprot.writeListEnd()
8195 
      oprot.writeFieldEnd()
8196 
    if self.isex is not None:
8197 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8198 
      self.isex.write(oprot)
8199 
      oprot.writeFieldEnd()
8200 
    oprot.writeFieldStop()
8201 
    oprot.writeStructEnd()
8202 
 
8203 
  def validate(self):
8204 
    return
8205 
 
8206 
 
8207 
  def __repr__(self):
8208 
    L = ['%s=%r' % (key, value)
8209 
      for key, value in self.__dict__.iteritems()]
8210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8211 
 
8212 
  def __eq__(self, other):
8213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8214 
 
8215 
  def __ne__(self, other):
8216 
    return not (self == other)
8217 
 
8218 
class getBestDealsCatalogIds_args:
8219 
  """
8220 
  Attributes:
8221 
   - beginIndex
8222 
   - totalItems
8223 
   - brand
8224 
   - category
8225 
  """
8226 
 
8227 
  thrift_spec = (
8228 
    None, # 0
8229 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8230 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8231 
    (3, TType.STRING, 'brand', None, None, ), # 3
8232 
    (4, TType.I64, 'category', None, None, ), # 4
8233 
  )
8234 
 
8235 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8236 
    self.beginIndex = beginIndex
8237 
    self.totalItems = totalItems
8238 
    self.brand = brand
8239 
    self.category = category
8240 
 
8241 
  def read(self, iprot):
8242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8244 
      return
8245 
    iprot.readStructBegin()
8246 
    while True:
8247 
      (fname, ftype, fid) = iprot.readFieldBegin()
8248 
      if ftype == TType.STOP:
8249 
        break
8250 
      if fid == 1:
8251 
        if ftype == TType.I64:
8252 
          self.beginIndex = iprot.readI64();
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      elif fid == 2:
8256 
        if ftype == TType.I64:
8257 
          self.totalItems = iprot.readI64();
8258 
        else:
8259 
          iprot.skip(ftype)
8260 
      elif fid == 3:
8261 
        if ftype == TType.STRING:
8262 
          self.brand = iprot.readString();
8263 
        else:
8264 
          iprot.skip(ftype)
8265 
      elif fid == 4:
8266 
        if ftype == TType.I64:
8267 
          self.category = iprot.readI64();
8268 
        else:
8269 
          iprot.skip(ftype)
8270 
      else:
8271 
        iprot.skip(ftype)
8272 
      iprot.readFieldEnd()
8273 
    iprot.readStructEnd()
8274 
 
8275 
  def write(self, oprot):
8276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8278 
      return
8279 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8280 
    if self.beginIndex is not None:
8281 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8282 
      oprot.writeI64(self.beginIndex)
8283 
      oprot.writeFieldEnd()
8284 
    if self.totalItems is not None:
8285 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8286 
      oprot.writeI64(self.totalItems)
8287 
      oprot.writeFieldEnd()
8288 
    if self.brand is not None:
8289 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8290 
      oprot.writeString(self.brand)
8291 
      oprot.writeFieldEnd()
8292 
    if self.category is not None:
8293 
      oprot.writeFieldBegin('category', TType.I64, 4)
8294 
      oprot.writeI64(self.category)
8295 
      oprot.writeFieldEnd()
8296 
    oprot.writeFieldStop()
8297 
    oprot.writeStructEnd()
8298 
 
8299 
  def validate(self):
8300 
    return
8301 
 
8302 
 
8303 
  def __repr__(self):
8304 
    L = ['%s=%r' % (key, value)
8305 
      for key, value in self.__dict__.iteritems()]
8306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8307 
 
8308 
  def __eq__(self, other):
8309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8310 
 
8311 
  def __ne__(self, other):
8312 
    return not (self == other)
8313 
 
8314 
class getBestDealsCatalogIds_result:
8315 
  """
8316 
  Attributes:
8317 
   - success
8318 
   - cex
8319 
  """
8320 
 
8321 
  thrift_spec = (
8322 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8323 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8324 
  )
8325 
 
8326 
  def __init__(self, success=None, cex=None,):
8327 
    self.success = success
8328 
    self.cex = cex
8329 
 
8330 
  def read(self, iprot):
8331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8333 
      return
8334 
    iprot.readStructBegin()
8335 
    while True:
8336 
      (fname, ftype, fid) = iprot.readFieldBegin()
8337 
      if ftype == TType.STOP:
8338 
        break
8339 
      if fid == 0:
8340 
        if ftype == TType.LIST:
8341 
          self.success = []
7438 amit.gupta 8342 
          (_etype98, _size95) = iprot.readListBegin()
8343 
          for _i99 in xrange(_size95):
8344 
            _elem100 = iprot.readI64();
8345 
            self.success.append(_elem100)
5944 mandeep.dh 8346 
          iprot.readListEnd()
8347 
        else:
8348 
          iprot.skip(ftype)
8349 
      elif fid == 1:
8350 
        if ftype == TType.STRUCT:
8351 
          self.cex = CatalogServiceException()
8352 
          self.cex.read(iprot)
8353 
        else:
8354 
          iprot.skip(ftype)
8355 
      else:
8356 
        iprot.skip(ftype)
8357 
      iprot.readFieldEnd()
8358 
    iprot.readStructEnd()
8359 
 
8360 
  def write(self, oprot):
8361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8363 
      return
8364 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8365 
    if self.success is not None:
8366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8367 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8368 
      for iter101 in self.success:
8369 
        oprot.writeI64(iter101)
5944 mandeep.dh 8370 
      oprot.writeListEnd()
8371 
      oprot.writeFieldEnd()
8372 
    if self.cex is not None:
8373 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8374 
      self.cex.write(oprot)
8375 
      oprot.writeFieldEnd()
8376 
    oprot.writeFieldStop()
8377 
    oprot.writeStructEnd()
8378 
 
8379 
  def validate(self):
8380 
    return
8381 
 
8382 
 
8383 
  def __repr__(self):
8384 
    L = ['%s=%r' % (key, value)
8385 
      for key, value in self.__dict__.iteritems()]
8386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8387 
 
8388 
  def __eq__(self, other):
8389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8390 
 
8391 
  def __ne__(self, other):
8392 
    return not (self == other)
8393 
 
8394 
class getBestDealsCount_args:
8395 
 
8396 
  thrift_spec = (
8397 
  )
8398 
 
8399 
  def read(self, iprot):
8400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8402 
      return
8403 
    iprot.readStructBegin()
8404 
    while True:
8405 
      (fname, ftype, fid) = iprot.readFieldBegin()
8406 
      if ftype == TType.STOP:
8407 
        break
8408 
      else:
8409 
        iprot.skip(ftype)
8410 
      iprot.readFieldEnd()
8411 
    iprot.readStructEnd()
8412 
 
8413 
  def write(self, oprot):
8414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8416 
      return
8417 
    oprot.writeStructBegin('getBestDealsCount_args')
8418 
    oprot.writeFieldStop()
8419 
    oprot.writeStructEnd()
8420 
 
8421 
  def validate(self):
8422 
    return
8423 
 
8424 
 
8425 
  def __repr__(self):
8426 
    L = ['%s=%r' % (key, value)
8427 
      for key, value in self.__dict__.iteritems()]
8428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8429 
 
8430 
  def __eq__(self, other):
8431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8432 
 
8433 
  def __ne__(self, other):
8434 
    return not (self == other)
8435 
 
8436 
class getBestDealsCount_result:
8437 
  """
8438 
  Attributes:
8439 
   - success
8440 
   - cex
8441 
  """
8442 
 
8443 
  thrift_spec = (
8444 
    (0, TType.I64, 'success', None, None, ), # 0
8445 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8446 
  )
8447 
 
8448 
  def __init__(self, success=None, cex=None,):
8449 
    self.success = success
8450 
    self.cex = cex
8451 
 
8452 
  def read(self, iprot):
8453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8455 
      return
8456 
    iprot.readStructBegin()
8457 
    while True:
8458 
      (fname, ftype, fid) = iprot.readFieldBegin()
8459 
      if ftype == TType.STOP:
8460 
        break
8461 
      if fid == 0:
8462 
        if ftype == TType.I64:
8463 
          self.success = iprot.readI64();
8464 
        else:
8465 
          iprot.skip(ftype)
8466 
      elif fid == 1:
8467 
        if ftype == TType.STRUCT:
8468 
          self.cex = CatalogServiceException()
8469 
          self.cex.read(iprot)
8470 
        else:
8471 
          iprot.skip(ftype)
8472 
      else:
8473 
        iprot.skip(ftype)
8474 
      iprot.readFieldEnd()
8475 
    iprot.readStructEnd()
8476 
 
8477 
  def write(self, oprot):
8478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8480 
      return
8481 
    oprot.writeStructBegin('getBestDealsCount_result')
8482 
    if self.success is not None:
8483 
      oprot.writeFieldBegin('success', TType.I64, 0)
8484 
      oprot.writeI64(self.success)
8485 
      oprot.writeFieldEnd()
8486 
    if self.cex is not None:
8487 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8488 
      self.cex.write(oprot)
8489 
      oprot.writeFieldEnd()
8490 
    oprot.writeFieldStop()
8491 
    oprot.writeStructEnd()
8492 
 
8493 
  def validate(self):
8494 
    return
8495 
 
8496 
 
8497 
  def __repr__(self):
8498 
    L = ['%s=%r' % (key, value)
8499 
      for key, value in self.__dict__.iteritems()]
8500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8501 
 
8502 
  def __eq__(self, other):
8503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8504 
 
8505 
  def __ne__(self, other):
8506 
    return not (self == other)
8507 
 
8508 
class getComingSoon_args:
8509 
 
8510 
  thrift_spec = (
8511 
  )
8512 
 
8513 
  def read(self, iprot):
8514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8516 
      return
8517 
    iprot.readStructBegin()
8518 
    while True:
8519 
      (fname, ftype, fid) = iprot.readFieldBegin()
8520 
      if ftype == TType.STOP:
8521 
        break
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
8531 
    oprot.writeStructBegin('getComingSoon_args')
8532 
    oprot.writeFieldStop()
8533 
    oprot.writeStructEnd()
8534 
 
8535 
  def validate(self):
8536 
    return
8537 
 
8538 
 
8539 
  def __repr__(self):
8540 
    L = ['%s=%r' % (key, value)
8541 
      for key, value in self.__dict__.iteritems()]
8542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8543 
 
8544 
  def __eq__(self, other):
8545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8546 
 
8547 
  def __ne__(self, other):
8548 
    return not (self == other)
8549 
 
8550 
class getComingSoon_result:
8551 
  """
8552 
  Attributes:
8553 
   - success
8554 
   - isex
8555 
  """
8556 
 
8557 
  thrift_spec = (
8558 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8559 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8560 
  )
8561 
 
8562 
  def __init__(self, success=None, isex=None,):
8563 
    self.success = success
8564 
    self.isex = isex
8565 
 
8566 
  def read(self, iprot):
8567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8569 
      return
8570 
    iprot.readStructBegin()
8571 
    while True:
8572 
      (fname, ftype, fid) = iprot.readFieldBegin()
8573 
      if ftype == TType.STOP:
8574 
        break
8575 
      if fid == 0:
8576 
        if ftype == TType.LIST:
8577 
          self.success = []
7438 amit.gupta 8578 
          (_etype105, _size102) = iprot.readListBegin()
8579 
          for _i106 in xrange(_size102):
8580 
            _elem107 = Item()
8581 
            _elem107.read(iprot)
8582 
            self.success.append(_elem107)
5944 mandeep.dh 8583 
          iprot.readListEnd()
8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      elif fid == 1:
8587 
        if ftype == TType.STRUCT:
8588 
          self.isex = CatalogServiceException()
8589 
          self.isex.read(iprot)
8590 
        else:
8591 
          iprot.skip(ftype)
8592 
      else:
8593 
        iprot.skip(ftype)
8594 
      iprot.readFieldEnd()
8595 
    iprot.readStructEnd()
8596 
 
8597 
  def write(self, oprot):
8598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8600 
      return
8601 
    oprot.writeStructBegin('getComingSoon_result')
8602 
    if self.success is not None:
8603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8605 
      for iter108 in self.success:
8606 
        iter108.write(oprot)
5944 mandeep.dh 8607 
      oprot.writeListEnd()
8608 
      oprot.writeFieldEnd()
8609 
    if self.isex is not None:
8610 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8611 
      self.isex.write(oprot)
8612 
      oprot.writeFieldEnd()
8613 
    oprot.writeFieldStop()
8614 
    oprot.writeStructEnd()
8615 
 
8616 
  def validate(self):
8617 
    return
8618 
 
8619 
 
8620 
  def __repr__(self):
8621 
    L = ['%s=%r' % (key, value)
8622 
      for key, value in self.__dict__.iteritems()]
8623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8624 
 
8625 
  def __eq__(self, other):
8626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8627 
 
8628 
  def __ne__(self, other):
8629 
    return not (self == other)
8630 
 
8631 
class getComingSoonCatalogIds_args:
8632 
  """
8633 
  Attributes:
8634 
   - beginIndex
8635 
   - totalItems
8636 
   - brand
8637 
   - category
8638 
  """
8639 
 
8640 
  thrift_spec = (
8641 
    None, # 0
8642 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8643 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8644 
    (3, TType.STRING, 'brand', None, None, ), # 3
8645 
    (4, TType.I64, 'category', None, None, ), # 4
8646 
  )
8647 
 
8648 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8649 
    self.beginIndex = beginIndex
8650 
    self.totalItems = totalItems
8651 
    self.brand = brand
8652 
    self.category = category
8653 
 
8654 
  def read(self, iprot):
8655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8657 
      return
8658 
    iprot.readStructBegin()
8659 
    while True:
8660 
      (fname, ftype, fid) = iprot.readFieldBegin()
8661 
      if ftype == TType.STOP:
8662 
        break
8663 
      if fid == 1:
8664 
        if ftype == TType.I64:
8665 
          self.beginIndex = iprot.readI64();
8666 
        else:
8667 
          iprot.skip(ftype)
8668 
      elif fid == 2:
8669 
        if ftype == TType.I64:
8670 
          self.totalItems = iprot.readI64();
8671 
        else:
8672 
          iprot.skip(ftype)
8673 
      elif fid == 3:
8674 
        if ftype == TType.STRING:
8675 
          self.brand = iprot.readString();
8676 
        else:
8677 
          iprot.skip(ftype)
8678 
      elif fid == 4:
8679 
        if ftype == TType.I64:
8680 
          self.category = iprot.readI64();
8681 
        else:
8682 
          iprot.skip(ftype)
8683 
      else:
8684 
        iprot.skip(ftype)
8685 
      iprot.readFieldEnd()
8686 
    iprot.readStructEnd()
8687 
 
8688 
  def write(self, oprot):
8689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8691 
      return
8692 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8693 
    if self.beginIndex is not None:
8694 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8695 
      oprot.writeI64(self.beginIndex)
8696 
      oprot.writeFieldEnd()
8697 
    if self.totalItems is not None:
8698 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8699 
      oprot.writeI64(self.totalItems)
8700 
      oprot.writeFieldEnd()
8701 
    if self.brand is not None:
8702 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8703 
      oprot.writeString(self.brand)
8704 
      oprot.writeFieldEnd()
8705 
    if self.category is not None:
8706 
      oprot.writeFieldBegin('category', TType.I64, 4)
8707 
      oprot.writeI64(self.category)
8708 
      oprot.writeFieldEnd()
8709 
    oprot.writeFieldStop()
8710 
    oprot.writeStructEnd()
8711 
 
8712 
  def validate(self):
8713 
    return
8714 
 
8715 
 
8716 
  def __repr__(self):
8717 
    L = ['%s=%r' % (key, value)
8718 
      for key, value in self.__dict__.iteritems()]
8719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8720 
 
8721 
  def __eq__(self, other):
8722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8723 
 
8724 
  def __ne__(self, other):
8725 
    return not (self == other)
8726 
 
8727 
class getComingSoonCatalogIds_result:
8728 
  """
8729 
  Attributes:
8730 
   - success
8731 
   - cex
8732 
  """
8733 
 
8734 
  thrift_spec = (
8735 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8736 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8737 
  )
8738 
 
8739 
  def __init__(self, success=None, cex=None,):
8740 
    self.success = success
8741 
    self.cex = cex
8742 
 
8743 
  def read(self, iprot):
8744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8746 
      return
8747 
    iprot.readStructBegin()
8748 
    while True:
8749 
      (fname, ftype, fid) = iprot.readFieldBegin()
8750 
      if ftype == TType.STOP:
8751 
        break
8752 
      if fid == 0:
8753 
        if ftype == TType.LIST:
8754 
          self.success = []
7438 amit.gupta 8755 
          (_etype112, _size109) = iprot.readListBegin()
8756 
          for _i113 in xrange(_size109):
8757 
            _elem114 = iprot.readI64();
8758 
            self.success.append(_elem114)
5944 mandeep.dh 8759 
          iprot.readListEnd()
8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      elif fid == 1:
8763 
        if ftype == TType.STRUCT:
8764 
          self.cex = CatalogServiceException()
8765 
          self.cex.read(iprot)
8766 
        else:
8767 
          iprot.skip(ftype)
8768 
      else:
8769 
        iprot.skip(ftype)
8770 
      iprot.readFieldEnd()
8771 
    iprot.readStructEnd()
8772 
 
8773 
  def write(self, oprot):
8774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8776 
      return
8777 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8778 
    if self.success is not None:
8779 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8780 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8781 
      for iter115 in self.success:
8782 
        oprot.writeI64(iter115)
5944 mandeep.dh 8783 
      oprot.writeListEnd()
8784 
      oprot.writeFieldEnd()
8785 
    if self.cex is not None:
8786 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8787 
      self.cex.write(oprot)
8788 
      oprot.writeFieldEnd()
8789 
    oprot.writeFieldStop()
8790 
    oprot.writeStructEnd()
8791 
 
8792 
  def validate(self):
8793 
    return
8794 
 
8795 
 
8796 
  def __repr__(self):
8797 
    L = ['%s=%r' % (key, value)
8798 
      for key, value in self.__dict__.iteritems()]
8799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8800 
 
8801 
  def __eq__(self, other):
8802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8803 
 
8804 
  def __ne__(self, other):
8805 
    return not (self == other)
8806 
 
8807 
class getComingSoonCount_args:
8808 
 
8809 
  thrift_spec = (
8810 
  )
8811 
 
8812 
  def read(self, iprot):
8813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8815 
      return
8816 
    iprot.readStructBegin()
8817 
    while True:
8818 
      (fname, ftype, fid) = iprot.readFieldBegin()
8819 
      if ftype == TType.STOP:
8820 
        break
8821 
      else:
8822 
        iprot.skip(ftype)
8823 
      iprot.readFieldEnd()
8824 
    iprot.readStructEnd()
8825 
 
8826 
  def write(self, oprot):
8827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8829 
      return
8830 
    oprot.writeStructBegin('getComingSoonCount_args')
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
8849 
class getComingSoonCount_result:
8850 
  """
8851 
  Attributes:
8852 
   - success
8853 
   - cex
8854 
  """
8855 
 
8856 
  thrift_spec = (
8857 
    (0, TType.I64, 'success', None, None, ), # 0
8858 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8859 
  )
8860 
 
8861 
  def __init__(self, success=None, cex=None,):
8862 
    self.success = success
8863 
    self.cex = cex
8864 
 
8865 
  def read(self, iprot):
8866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8868 
      return
8869 
    iprot.readStructBegin()
8870 
    while True:
8871 
      (fname, ftype, fid) = iprot.readFieldBegin()
8872 
      if ftype == TType.STOP:
8873 
        break
8874 
      if fid == 0:
8875 
        if ftype == TType.I64:
8876 
          self.success = iprot.readI64();
8877 
        else:
8878 
          iprot.skip(ftype)
8879 
      elif fid == 1:
8880 
        if ftype == TType.STRUCT:
8881 
          self.cex = CatalogServiceException()
8882 
          self.cex.read(iprot)
8883 
        else:
8884 
          iprot.skip(ftype)
8885 
      else:
8886 
        iprot.skip(ftype)
8887 
      iprot.readFieldEnd()
8888 
    iprot.readStructEnd()
8889 
 
8890 
  def write(self, oprot):
8891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8893 
      return
8894 
    oprot.writeStructBegin('getComingSoonCount_result')
8895 
    if self.success is not None:
8896 
      oprot.writeFieldBegin('success', TType.I64, 0)
8897 
      oprot.writeI64(self.success)
8898 
      oprot.writeFieldEnd()
8899 
    if self.cex is not None:
8900 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8901 
      self.cex.write(oprot)
8902 
      oprot.writeFieldEnd()
8903 
    oprot.writeFieldStop()
8904 
    oprot.writeStructEnd()
8905 
 
8906 
  def validate(self):
8907 
    return
8908 
 
8909 
 
8910 
  def __repr__(self):
8911 
    L = ['%s=%r' % (key, value)
8912 
      for key, value in self.__dict__.iteritems()]
8913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8914 
 
8915 
  def __eq__(self, other):
8916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8917 
 
8918 
  def __ne__(self, other):
8919 
    return not (self == other)
8920 
 
8921 
class getLatestArrivals_args:
8922 
 
8923 
  thrift_spec = (
8924 
  )
8925 
 
8926 
  def read(self, iprot):
8927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8929 
      return
8930 
    iprot.readStructBegin()
8931 
    while True:
8932 
      (fname, ftype, fid) = iprot.readFieldBegin()
8933 
      if ftype == TType.STOP:
8934 
        break
8935 
      else:
8936 
        iprot.skip(ftype)
8937 
      iprot.readFieldEnd()
8938 
    iprot.readStructEnd()
8939 
 
8940 
  def write(self, oprot):
8941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8943 
      return
8944 
    oprot.writeStructBegin('getLatestArrivals_args')
8945 
    oprot.writeFieldStop()
8946 
    oprot.writeStructEnd()
8947 
 
8948 
  def validate(self):
8949 
    return
8950 
 
8951 
 
8952 
  def __repr__(self):
8953 
    L = ['%s=%r' % (key, value)
8954 
      for key, value in self.__dict__.iteritems()]
8955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8956 
 
8957 
  def __eq__(self, other):
8958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8959 
 
8960 
  def __ne__(self, other):
8961 
    return not (self == other)
8962 
 
8963 
class getLatestArrivals_result:
8964 
  """
8965 
  Attributes:
8966 
   - success
8967 
   - isex
8968 
  """
8969 
 
8970 
  thrift_spec = (
8971 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8972 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8973 
  )
8974 
 
8975 
  def __init__(self, success=None, isex=None,):
8976 
    self.success = success
8977 
    self.isex = isex
8978 
 
8979 
  def read(self, iprot):
8980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8982 
      return
8983 
    iprot.readStructBegin()
8984 
    while True:
8985 
      (fname, ftype, fid) = iprot.readFieldBegin()
8986 
      if ftype == TType.STOP:
8987 
        break
8988 
      if fid == 0:
8989 
        if ftype == TType.LIST:
8990 
          self.success = []
7438 amit.gupta 8991 
          (_etype119, _size116) = iprot.readListBegin()
8992 
          for _i120 in xrange(_size116):
8993 
            _elem121 = Item()
8994 
            _elem121.read(iprot)
8995 
            self.success.append(_elem121)
5944 mandeep.dh 8996 
          iprot.readListEnd()
8997 
        else:
8998 
          iprot.skip(ftype)
8999 
      elif fid == 1:
9000 
        if ftype == TType.STRUCT:
9001 
          self.isex = CatalogServiceException()
9002 
          self.isex.read(iprot)
9003 
        else:
9004 
          iprot.skip(ftype)
9005 
      else:
9006 
        iprot.skip(ftype)
9007 
      iprot.readFieldEnd()
9008 
    iprot.readStructEnd()
9009 
 
9010 
  def write(self, oprot):
9011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9013 
      return
9014 
    oprot.writeStructBegin('getLatestArrivals_result')
9015 
    if self.success is not None:
9016 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9017 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9018 
      for iter122 in self.success:
9019 
        iter122.write(oprot)
5944 mandeep.dh 9020 
      oprot.writeListEnd()
9021 
      oprot.writeFieldEnd()
9022 
    if self.isex is not None:
9023 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9024 
      self.isex.write(oprot)
9025 
      oprot.writeFieldEnd()
9026 
    oprot.writeFieldStop()
9027 
    oprot.writeStructEnd()
9028 
 
9029 
  def validate(self):
9030 
    return
9031 
 
9032 
 
9033 
  def __repr__(self):
9034 
    L = ['%s=%r' % (key, value)
9035 
      for key, value in self.__dict__.iteritems()]
9036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9037 
 
9038 
  def __eq__(self, other):
9039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9040 
 
9041 
  def __ne__(self, other):
9042 
    return not (self == other)
9043 
 
9044 
class getLatestArrivalsCatalogIds_args:
9045 
  """
9046 
  Attributes:
9047 
   - beginIndex
9048 
   - totalItems
9049 
   - brand
9050 
   - categories
9051 
  """
9052 
 
9053 
  thrift_spec = (
9054 
    None, # 0
9055 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9056 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9057 
    (3, TType.STRING, 'brand', None, None, ), # 3
9058 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9059 
  )
9060 
 
9061 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9062 
    self.beginIndex = beginIndex
9063 
    self.totalItems = totalItems
9064 
    self.brand = brand
9065 
    self.categories = categories
9066 
 
9067 
  def read(self, iprot):
9068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9070 
      return
9071 
    iprot.readStructBegin()
9072 
    while True:
9073 
      (fname, ftype, fid) = iprot.readFieldBegin()
9074 
      if ftype == TType.STOP:
9075 
        break
9076 
      if fid == 1:
9077 
        if ftype == TType.I64:
9078 
          self.beginIndex = iprot.readI64();
9079 
        else:
9080 
          iprot.skip(ftype)
9081 
      elif fid == 2:
9082 
        if ftype == TType.I64:
9083 
          self.totalItems = iprot.readI64();
9084 
        else:
9085 
          iprot.skip(ftype)
9086 
      elif fid == 3:
9087 
        if ftype == TType.STRING:
9088 
          self.brand = iprot.readString();
9089 
        else:
9090 
          iprot.skip(ftype)
9091 
      elif fid == 4:
9092 
        if ftype == TType.LIST:
9093 
          self.categories = []
7438 amit.gupta 9094 
          (_etype126, _size123) = iprot.readListBegin()
9095 
          for _i127 in xrange(_size123):
9096 
            _elem128 = iprot.readI64();
9097 
            self.categories.append(_elem128)
5944 mandeep.dh 9098 
          iprot.readListEnd()
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      else:
9102 
        iprot.skip(ftype)
9103 
      iprot.readFieldEnd()
9104 
    iprot.readStructEnd()
9105 
 
9106 
  def write(self, oprot):
9107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9109 
      return
9110 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9111 
    if self.beginIndex is not None:
9112 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9113 
      oprot.writeI64(self.beginIndex)
9114 
      oprot.writeFieldEnd()
9115 
    if self.totalItems is not None:
9116 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9117 
      oprot.writeI64(self.totalItems)
9118 
      oprot.writeFieldEnd()
9119 
    if self.brand is not None:
9120 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9121 
      oprot.writeString(self.brand)
9122 
      oprot.writeFieldEnd()
9123 
    if self.categories is not None:
9124 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9125 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9126 
      for iter129 in self.categories:
9127 
        oprot.writeI64(iter129)
5944 mandeep.dh 9128 
      oprot.writeListEnd()
9129 
      oprot.writeFieldEnd()
9130 
    oprot.writeFieldStop()
9131 
    oprot.writeStructEnd()
9132 
 
9133 
  def validate(self):
9134 
    return
9135 
 
9136 
 
9137 
  def __repr__(self):
9138 
    L = ['%s=%r' % (key, value)
9139 
      for key, value in self.__dict__.iteritems()]
9140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9141 
 
9142 
  def __eq__(self, other):
9143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9144 
 
9145 
  def __ne__(self, other):
9146 
    return not (self == other)
9147 
 
9148 
class getLatestArrivalsCatalogIds_result:
9149 
  """
9150 
  Attributes:
9151 
   - success
9152 
   - cex
9153 
  """
9154 
 
9155 
  thrift_spec = (
9156 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9157 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9158 
  )
9159 
 
9160 
  def __init__(self, success=None, cex=None,):
9161 
    self.success = success
9162 
    self.cex = cex
9163 
 
9164 
  def read(self, iprot):
9165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9167 
      return
9168 
    iprot.readStructBegin()
9169 
    while True:
9170 
      (fname, ftype, fid) = iprot.readFieldBegin()
9171 
      if ftype == TType.STOP:
9172 
        break
9173 
      if fid == 0:
9174 
        if ftype == TType.LIST:
9175 
          self.success = []
7438 amit.gupta 9176 
          (_etype133, _size130) = iprot.readListBegin()
9177 
          for _i134 in xrange(_size130):
9178 
            _elem135 = iprot.readI64();
9179 
            self.success.append(_elem135)
5944 mandeep.dh 9180 
          iprot.readListEnd()
9181 
        else:
9182 
          iprot.skip(ftype)
9183 
      elif fid == 1:
9184 
        if ftype == TType.STRUCT:
9185 
          self.cex = CatalogServiceException()
9186 
          self.cex.read(iprot)
9187 
        else:
9188 
          iprot.skip(ftype)
9189 
      else:
9190 
        iprot.skip(ftype)
9191 
      iprot.readFieldEnd()
9192 
    iprot.readStructEnd()
9193 
 
9194 
  def write(self, oprot):
9195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9197 
      return
9198 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9199 
    if self.success is not None:
9200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9201 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9202 
      for iter136 in self.success:
9203 
        oprot.writeI64(iter136)
5944 mandeep.dh 9204 
      oprot.writeListEnd()
9205 
      oprot.writeFieldEnd()
9206 
    if self.cex is not None:
9207 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9208 
      self.cex.write(oprot)
9209 
      oprot.writeFieldEnd()
9210 
    oprot.writeFieldStop()
9211 
    oprot.writeStructEnd()
9212 
 
9213 
  def validate(self):
9214 
    return
9215 
 
9216 
 
9217 
  def __repr__(self):
9218 
    L = ['%s=%r' % (key, value)
9219 
      for key, value in self.__dict__.iteritems()]
9220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9221 
 
9222 
  def __eq__(self, other):
9223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9224 
 
9225 
  def __ne__(self, other):
9226 
    return not (self == other)
9227 
 
9228 
class getLatestArrivalsCount_args:
9229 
 
9230 
  thrift_spec = (
9231 
  )
9232 
 
9233 
  def read(self, iprot):
9234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9236 
      return
9237 
    iprot.readStructBegin()
9238 
    while True:
9239 
      (fname, ftype, fid) = iprot.readFieldBegin()
9240 
      if ftype == TType.STOP:
9241 
        break
9242 
      else:
9243 
        iprot.skip(ftype)
9244 
      iprot.readFieldEnd()
9245 
    iprot.readStructEnd()
9246 
 
9247 
  def write(self, oprot):
9248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9250 
      return
9251 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9252 
    oprot.writeFieldStop()
9253 
    oprot.writeStructEnd()
9254 
 
9255 
  def validate(self):
9256 
    return
9257 
 
9258 
 
9259 
  def __repr__(self):
9260 
    L = ['%s=%r' % (key, value)
9261 
      for key, value in self.__dict__.iteritems()]
9262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9263 
 
9264 
  def __eq__(self, other):
9265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9266 
 
9267 
  def __ne__(self, other):
9268 
    return not (self == other)
9269 
 
9270 
class getLatestArrivalsCount_result:
9271 
  """
9272 
  Attributes:
9273 
   - success
9274 
   - cex
9275 
  """
9276 
 
9277 
  thrift_spec = (
9278 
    (0, TType.I64, 'success', None, None, ), # 0
9279 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9280 
  )
9281 
 
9282 
  def __init__(self, success=None, cex=None,):
9283 
    self.success = success
9284 
    self.cex = cex
9285 
 
9286 
  def read(self, iprot):
9287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9289 
      return
9290 
    iprot.readStructBegin()
9291 
    while True:
9292 
      (fname, ftype, fid) = iprot.readFieldBegin()
9293 
      if ftype == TType.STOP:
9294 
        break
9295 
      if fid == 0:
9296 
        if ftype == TType.I64:
9297 
          self.success = iprot.readI64();
9298 
        else:
9299 
          iprot.skip(ftype)
9300 
      elif fid == 1:
9301 
        if ftype == TType.STRUCT:
9302 
          self.cex = CatalogServiceException()
9303 
          self.cex.read(iprot)
9304 
        else:
9305 
          iprot.skip(ftype)
9306 
      else:
9307 
        iprot.skip(ftype)
9308 
      iprot.readFieldEnd()
9309 
    iprot.readStructEnd()
9310 
 
9311 
  def write(self, oprot):
9312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9314 
      return
9315 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9316 
    if self.success is not None:
9317 
      oprot.writeFieldBegin('success', TType.I64, 0)
9318 
      oprot.writeI64(self.success)
9319 
      oprot.writeFieldEnd()
9320 
    if self.cex is not None:
9321 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9322 
      self.cex.write(oprot)
9323 
      oprot.writeFieldEnd()
9324 
    oprot.writeFieldStop()
9325 
    oprot.writeStructEnd()
9326 
 
9327 
  def validate(self):
9328 
    return
9329 
 
9330 
 
9331 
  def __repr__(self):
9332 
    L = ['%s=%r' % (key, value)
9333 
      for key, value in self.__dict__.iteritems()]
9334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9335 
 
9336 
  def __eq__(self, other):
9337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9338 
 
9339 
  def __ne__(self, other):
9340 
    return not (self == other)
9341 
 
9342 
class generateNewEntityID_args:
9343 
 
9344 
  thrift_spec = (
9345 
  )
9346 
 
9347 
  def read(self, iprot):
9348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9350 
      return
9351 
    iprot.readStructBegin()
9352 
    while True:
9353 
      (fname, ftype, fid) = iprot.readFieldBegin()
9354 
      if ftype == TType.STOP:
9355 
        break
9356 
      else:
9357 
        iprot.skip(ftype)
9358 
      iprot.readFieldEnd()
9359 
    iprot.readStructEnd()
9360 
 
9361 
  def write(self, oprot):
9362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9364 
      return
9365 
    oprot.writeStructBegin('generateNewEntityID_args')
9366 
    oprot.writeFieldStop()
9367 
    oprot.writeStructEnd()
9368 
 
9369 
  def validate(self):
9370 
    return
9371 
 
9372 
 
9373 
  def __repr__(self):
9374 
    L = ['%s=%r' % (key, value)
9375 
      for key, value in self.__dict__.iteritems()]
9376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9377 
 
9378 
  def __eq__(self, other):
9379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9380 
 
9381 
  def __ne__(self, other):
9382 
    return not (self == other)
9383 
 
9384 
class generateNewEntityID_result:
9385 
  """
9386 
  Attributes:
9387 
   - success
9388 
  """
9389 
 
9390 
  thrift_spec = (
9391 
    (0, TType.I64, 'success', None, None, ), # 0
9392 
  )
9393 
 
9394 
  def __init__(self, success=None,):
9395 
    self.success = success
9396 
 
9397 
  def read(self, iprot):
9398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9400 
      return
9401 
    iprot.readStructBegin()
9402 
    while True:
9403 
      (fname, ftype, fid) = iprot.readFieldBegin()
9404 
      if ftype == TType.STOP:
9405 
        break
9406 
      if fid == 0:
9407 
        if ftype == TType.I64:
9408 
          self.success = iprot.readI64();
9409 
        else:
9410 
          iprot.skip(ftype)
9411 
      else:
9412 
        iprot.skip(ftype)
9413 
      iprot.readFieldEnd()
9414 
    iprot.readStructEnd()
9415 
 
9416 
  def write(self, oprot):
9417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9419 
      return
9420 
    oprot.writeStructBegin('generateNewEntityID_result')
9421 
    if self.success is not None:
9422 
      oprot.writeFieldBegin('success', TType.I64, 0)
9423 
      oprot.writeI64(self.success)
9424 
      oprot.writeFieldEnd()
9425 
    oprot.writeFieldStop()
9426 
    oprot.writeStructEnd()
9427 
 
9428 
  def validate(self):
9429 
    return
9430 
 
9431 
 
9432 
  def __repr__(self):
9433 
    L = ['%s=%r' % (key, value)
9434 
      for key, value in self.__dict__.iteritems()]
9435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9436 
 
9437 
  def __eq__(self, other):
9438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9439 
 
9440 
  def __ne__(self, other):
9441 
    return not (self == other)
9442 
 
9443 
class addCategory_args:
9444 
  """
9445 
  Attributes:
9446 
   - category
9447 
  """
9448 
 
9449 
  thrift_spec = (
9450 
    None, # 0
9451 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9452 
  )
9453 
 
9454 
  def __init__(self, category=None,):
9455 
    self.category = category
9456 
 
9457 
  def read(self, iprot):
9458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9460 
      return
9461 
    iprot.readStructBegin()
9462 
    while True:
9463 
      (fname, ftype, fid) = iprot.readFieldBegin()
9464 
      if ftype == TType.STOP:
9465 
        break
9466 
      if fid == 1:
9467 
        if ftype == TType.STRUCT:
9468 
          self.category = Category()
9469 
          self.category.read(iprot)
9470 
        else:
9471 
          iprot.skip(ftype)
9472 
      else:
9473 
        iprot.skip(ftype)
9474 
      iprot.readFieldEnd()
9475 
    iprot.readStructEnd()
9476 
 
9477 
  def write(self, oprot):
9478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9480 
      return
9481 
    oprot.writeStructBegin('addCategory_args')
9482 
    if self.category is not None:
9483 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9484 
      self.category.write(oprot)
9485 
      oprot.writeFieldEnd()
9486 
    oprot.writeFieldStop()
9487 
    oprot.writeStructEnd()
9488 
 
9489 
  def validate(self):
9490 
    return
9491 
 
9492 
 
9493 
  def __repr__(self):
9494 
    L = ['%s=%r' % (key, value)
9495 
      for key, value in self.__dict__.iteritems()]
9496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9497 
 
9498 
  def __eq__(self, other):
9499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9500 
 
9501 
  def __ne__(self, other):
9502 
    return not (self == other)
9503 
 
9504 
class addCategory_result:
9505 
  """
9506 
  Attributes:
9507 
   - success
9508 
  """
9509 
 
9510 
  thrift_spec = (
9511 
    (0, TType.BOOL, 'success', None, None, ), # 0
9512 
  )
9513 
 
9514 
  def __init__(self, success=None,):
9515 
    self.success = success
9516 
 
9517 
  def read(self, iprot):
9518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9520 
      return
9521 
    iprot.readStructBegin()
9522 
    while True:
9523 
      (fname, ftype, fid) = iprot.readFieldBegin()
9524 
      if ftype == TType.STOP:
9525 
        break
9526 
      if fid == 0:
9527 
        if ftype == TType.BOOL:
9528 
          self.success = iprot.readBool();
9529 
        else:
9530 
          iprot.skip(ftype)
9531 
      else:
9532 
        iprot.skip(ftype)
9533 
      iprot.readFieldEnd()
9534 
    iprot.readStructEnd()
9535 
 
9536 
  def write(self, oprot):
9537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9539 
      return
9540 
    oprot.writeStructBegin('addCategory_result')
9541 
    if self.success is not None:
9542 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9543 
      oprot.writeBool(self.success)
9544 
      oprot.writeFieldEnd()
9545 
    oprot.writeFieldStop()
9546 
    oprot.writeStructEnd()
9547 
 
9548 
  def validate(self):
9549 
    return
9550 
 
9551 
 
9552 
  def __repr__(self):
9553 
    L = ['%s=%r' % (key, value)
9554 
      for key, value in self.__dict__.iteritems()]
9555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9556 
 
9557 
  def __eq__(self, other):
9558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9559 
 
9560 
  def __ne__(self, other):
9561 
    return not (self == other)
9562 
 
9563 
class getCategory_args:
9564 
  """
9565 
  Attributes:
9566 
   - id
9567 
  """
9568 
 
9569 
  thrift_spec = (
9570 
    None, # 0
9571 
    (1, TType.I64, 'id', None, None, ), # 1
9572 
  )
9573 
 
9574 
  def __init__(self, id=None,):
9575 
    self.id = id
9576 
 
9577 
  def read(self, iprot):
9578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9580 
      return
9581 
    iprot.readStructBegin()
9582 
    while True:
9583 
      (fname, ftype, fid) = iprot.readFieldBegin()
9584 
      if ftype == TType.STOP:
9585 
        break
9586 
      if fid == 1:
9587 
        if ftype == TType.I64:
9588 
          self.id = iprot.readI64();
9589 
        else:
9590 
          iprot.skip(ftype)
9591 
      else:
9592 
        iprot.skip(ftype)
9593 
      iprot.readFieldEnd()
9594 
    iprot.readStructEnd()
9595 
 
9596 
  def write(self, oprot):
9597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9599 
      return
9600 
    oprot.writeStructBegin('getCategory_args')
9601 
    if self.id is not None:
9602 
      oprot.writeFieldBegin('id', TType.I64, 1)
9603 
      oprot.writeI64(self.id)
9604 
      oprot.writeFieldEnd()
9605 
    oprot.writeFieldStop()
9606 
    oprot.writeStructEnd()
9607 
 
9608 
  def validate(self):
9609 
    return
9610 
 
9611 
 
9612 
  def __repr__(self):
9613 
    L = ['%s=%r' % (key, value)
9614 
      for key, value in self.__dict__.iteritems()]
9615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9616 
 
9617 
  def __eq__(self, other):
9618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9619 
 
9620 
  def __ne__(self, other):
9621 
    return not (self == other)
9622 
 
9623 
class getCategory_result:
9624 
  """
9625 
  Attributes:
9626 
   - success
9627 
  """
9628 
 
9629 
  thrift_spec = (
9630 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9631 
  )
9632 
 
9633 
  def __init__(self, success=None,):
9634 
    self.success = success
9635 
 
9636 
  def read(self, iprot):
9637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9639 
      return
9640 
    iprot.readStructBegin()
9641 
    while True:
9642 
      (fname, ftype, fid) = iprot.readFieldBegin()
9643 
      if ftype == TType.STOP:
9644 
        break
9645 
      if fid == 0:
9646 
        if ftype == TType.STRUCT:
9647 
          self.success = Category()
9648 
          self.success.read(iprot)
9649 
        else:
9650 
          iprot.skip(ftype)
9651 
      else:
9652 
        iprot.skip(ftype)
9653 
      iprot.readFieldEnd()
9654 
    iprot.readStructEnd()
9655 
 
9656 
  def write(self, oprot):
9657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9659 
      return
9660 
    oprot.writeStructBegin('getCategory_result')
9661 
    if self.success is not None:
9662 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9663 
      self.success.write(oprot)
9664 
      oprot.writeFieldEnd()
9665 
    oprot.writeFieldStop()
9666 
    oprot.writeStructEnd()
9667 
 
9668 
  def validate(self):
9669 
    return
9670 
 
9671 
 
9672 
  def __repr__(self):
9673 
    L = ['%s=%r' % (key, value)
9674 
      for key, value in self.__dict__.iteritems()]
9675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9676 
 
9677 
  def __eq__(self, other):
9678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9679 
 
9680 
  def __ne__(self, other):
9681 
    return not (self == other)
9682 
 
9683 
class getAllCategories_args:
9684 
 
9685 
  thrift_spec = (
9686 
  )
9687 
 
9688 
  def read(self, iprot):
9689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9691 
      return
9692 
    iprot.readStructBegin()
9693 
    while True:
9694 
      (fname, ftype, fid) = iprot.readFieldBegin()
9695 
      if ftype == TType.STOP:
9696 
        break
9697 
      else:
9698 
        iprot.skip(ftype)
9699 
      iprot.readFieldEnd()
9700 
    iprot.readStructEnd()
9701 
 
9702 
  def write(self, oprot):
9703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9705 
      return
9706 
    oprot.writeStructBegin('getAllCategories_args')
9707 
    oprot.writeFieldStop()
9708 
    oprot.writeStructEnd()
9709 
 
9710 
  def validate(self):
9711 
    return
9712 
 
9713 
 
9714 
  def __repr__(self):
9715 
    L = ['%s=%r' % (key, value)
9716 
      for key, value in self.__dict__.iteritems()]
9717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9718 
 
9719 
  def __eq__(self, other):
9720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9721 
 
9722 
  def __ne__(self, other):
9723 
    return not (self == other)
9724 
 
9725 
class getAllCategories_result:
9726 
  """
9727 
  Attributes:
9728 
   - success
9729 
  """
9730 
 
9731 
  thrift_spec = (
9732 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9733 
  )
9734 
 
9735 
  def __init__(self, success=None,):
9736 
    self.success = success
9737 
 
9738 
  def read(self, iprot):
9739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9741 
      return
9742 
    iprot.readStructBegin()
9743 
    while True:
9744 
      (fname, ftype, fid) = iprot.readFieldBegin()
9745 
      if ftype == TType.STOP:
9746 
        break
9747 
      if fid == 0:
9748 
        if ftype == TType.LIST:
9749 
          self.success = []
7438 amit.gupta 9750 
          (_etype140, _size137) = iprot.readListBegin()
9751 
          for _i141 in xrange(_size137):
9752 
            _elem142 = Category()
9753 
            _elem142.read(iprot)
9754 
            self.success.append(_elem142)
5944 mandeep.dh 9755 
          iprot.readListEnd()
9756 
        else:
9757 
          iprot.skip(ftype)
9758 
      else:
9759 
        iprot.skip(ftype)
9760 
      iprot.readFieldEnd()
9761 
    iprot.readStructEnd()
9762 
 
9763 
  def write(self, oprot):
9764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9766 
      return
9767 
    oprot.writeStructBegin('getAllCategories_result')
9768 
    if self.success is not None:
9769 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9770 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9771 
      for iter143 in self.success:
9772 
        iter143.write(oprot)
5944 mandeep.dh 9773 
      oprot.writeListEnd()
9774 
      oprot.writeFieldEnd()
9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
9778 
  def validate(self):
9779 
    return
9780 
 
9781 
 
9782 
  def __repr__(self):
9783 
    L = ['%s=%r' % (key, value)
9784 
      for key, value in self.__dict__.iteritems()]
9785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9786 
 
9787 
  def __eq__(self, other):
9788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9789 
 
9790 
  def __ne__(self, other):
9791 
    return not (self == other)
9792 
 
9793 
class getAllSimilarItems_args:
9794 
  """
9795 
  Attributes:
9796 
   - itemId
9797 
  """
9798 
 
9799 
  thrift_spec = (
9800 
    None, # 0
9801 
    (1, TType.I64, 'itemId', None, None, ), # 1
9802 
  )
9803 
 
9804 
  def __init__(self, itemId=None,):
9805 
    self.itemId = itemId
9806 
 
9807 
  def read(self, iprot):
9808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9810 
      return
9811 
    iprot.readStructBegin()
9812 
    while True:
9813 
      (fname, ftype, fid) = iprot.readFieldBegin()
9814 
      if ftype == TType.STOP:
9815 
        break
9816 
      if fid == 1:
9817 
        if ftype == TType.I64:
9818 
          self.itemId = iprot.readI64();
9819 
        else:
9820 
          iprot.skip(ftype)
9821 
      else:
9822 
        iprot.skip(ftype)
9823 
      iprot.readFieldEnd()
9824 
    iprot.readStructEnd()
9825 
 
9826 
  def write(self, oprot):
9827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9829 
      return
9830 
    oprot.writeStructBegin('getAllSimilarItems_args')
9831 
    if self.itemId is not None:
9832 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9833 
      oprot.writeI64(self.itemId)
9834 
      oprot.writeFieldEnd()
9835 
    oprot.writeFieldStop()
9836 
    oprot.writeStructEnd()
9837 
 
9838 
  def validate(self):
9839 
    return
9840 
 
9841 
 
9842 
  def __repr__(self):
9843 
    L = ['%s=%r' % (key, value)
9844 
      for key, value in self.__dict__.iteritems()]
9845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9846 
 
9847 
  def __eq__(self, other):
9848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9849 
 
9850 
  def __ne__(self, other):
9851 
    return not (self == other)
9852 
 
9853 
class getAllSimilarItems_result:
9854 
  """
9855 
  Attributes:
9856 
   - success
9857 
  """
9858 
 
9859 
  thrift_spec = (
9860 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9861 
  )
9862 
 
9863 
  def __init__(self, success=None,):
9864 
    self.success = success
9865 
 
9866 
  def read(self, iprot):
9867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9869 
      return
9870 
    iprot.readStructBegin()
9871 
    while True:
9872 
      (fname, ftype, fid) = iprot.readFieldBegin()
9873 
      if ftype == TType.STOP:
9874 
        break
9875 
      if fid == 0:
9876 
        if ftype == TType.LIST:
9877 
          self.success = []
7438 amit.gupta 9878 
          (_etype147, _size144) = iprot.readListBegin()
9879 
          for _i148 in xrange(_size144):
9880 
            _elem149 = Item()
9881 
            _elem149.read(iprot)
9882 
            self.success.append(_elem149)
5944 mandeep.dh 9883 
          iprot.readListEnd()
9884 
        else:
9885 
          iprot.skip(ftype)
9886 
      else:
9887 
        iprot.skip(ftype)
9888 
      iprot.readFieldEnd()
9889 
    iprot.readStructEnd()
9890 
 
9891 
  def write(self, oprot):
9892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9894 
      return
9895 
    oprot.writeStructBegin('getAllSimilarItems_result')
9896 
    if self.success is not None:
9897 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9898 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9899 
      for iter150 in self.success:
9900 
        iter150.write(oprot)
5944 mandeep.dh 9901 
      oprot.writeListEnd()
9902 
      oprot.writeFieldEnd()
9903 
    oprot.writeFieldStop()
9904 
    oprot.writeStructEnd()
9905 
 
9906 
  def validate(self):
9907 
    return
9908 
 
9909 
 
9910 
  def __repr__(self):
9911 
    L = ['%s=%r' % (key, value)
9912 
      for key, value in self.__dict__.iteritems()]
9913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9914 
 
9915 
  def __eq__(self, other):
9916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9917 
 
9918 
  def __ne__(self, other):
9919 
    return not (self == other)
9920 
 
9921 
class addSimilarItem_args:
9922 
  """
9923 
  Attributes:
9924 
   - itemId
9925 
   - catalogItemId
9926 
  """
9927 
 
9928 
  thrift_spec = (
9929 
    None, # 0
9930 
    (1, TType.I64, 'itemId', None, None, ), # 1
9931 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9932 
  )
9933 
 
9934 
  def __init__(self, itemId=None, catalogItemId=None,):
9935 
    self.itemId = itemId
9936 
    self.catalogItemId = catalogItemId
9937 
 
9938 
  def read(self, iprot):
9939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9941 
      return
9942 
    iprot.readStructBegin()
9943 
    while True:
9944 
      (fname, ftype, fid) = iprot.readFieldBegin()
9945 
      if ftype == TType.STOP:
9946 
        break
9947 
      if fid == 1:
9948 
        if ftype == TType.I64:
9949 
          self.itemId = iprot.readI64();
9950 
        else:
9951 
          iprot.skip(ftype)
9952 
      elif fid == 2:
9953 
        if ftype == TType.I64:
9954 
          self.catalogItemId = iprot.readI64();
9955 
        else:
9956 
          iprot.skip(ftype)
9957 
      else:
9958 
        iprot.skip(ftype)
9959 
      iprot.readFieldEnd()
9960 
    iprot.readStructEnd()
9961 
 
9962 
  def write(self, oprot):
9963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9965 
      return
9966 
    oprot.writeStructBegin('addSimilarItem_args')
9967 
    if self.itemId is not None:
9968 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9969 
      oprot.writeI64(self.itemId)
9970 
      oprot.writeFieldEnd()
9971 
    if self.catalogItemId is not None:
9972 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9973 
      oprot.writeI64(self.catalogItemId)
9974 
      oprot.writeFieldEnd()
9975 
    oprot.writeFieldStop()
9976 
    oprot.writeStructEnd()
9977 
 
9978 
  def validate(self):
9979 
    return
9980 
 
9981 
 
9982 
  def __repr__(self):
9983 
    L = ['%s=%r' % (key, value)
9984 
      for key, value in self.__dict__.iteritems()]
9985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9986 
 
9987 
  def __eq__(self, other):
9988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9989 
 
9990 
  def __ne__(self, other):
9991 
    return not (self == other)
9992 
 
9993 
class addSimilarItem_result:
9994 
  """
9995 
  Attributes:
9996 
   - success
9997 
   - cex
9998 
  """
9999 
 
10000 
  thrift_spec = (
10001 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10002 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10003 
  )
10004 
 
10005 
  def __init__(self, success=None, cex=None,):
10006 
    self.success = success
10007 
    self.cex = cex
10008 
 
10009 
  def read(self, iprot):
10010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10012 
      return
10013 
    iprot.readStructBegin()
10014 
    while True:
10015 
      (fname, ftype, fid) = iprot.readFieldBegin()
10016 
      if ftype == TType.STOP:
10017 
        break
10018 
      if fid == 0:
10019 
        if ftype == TType.STRUCT:
10020 
          self.success = Item()
10021 
          self.success.read(iprot)
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 1:
10025 
        if ftype == TType.STRUCT:
10026 
          self.cex = CatalogServiceException()
10027 
          self.cex.read(iprot)
10028 
        else:
10029 
          iprot.skip(ftype)
10030 
      else:
10031 
        iprot.skip(ftype)
10032 
      iprot.readFieldEnd()
10033 
    iprot.readStructEnd()
10034 
 
10035 
  def write(self, oprot):
10036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10038 
      return
10039 
    oprot.writeStructBegin('addSimilarItem_result')
10040 
    if self.success is not None:
10041 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10042 
      self.success.write(oprot)
10043 
      oprot.writeFieldEnd()
10044 
    if self.cex is not None:
10045 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10046 
      self.cex.write(oprot)
10047 
      oprot.writeFieldEnd()
10048 
    oprot.writeFieldStop()
10049 
    oprot.writeStructEnd()
10050 
 
10051 
  def validate(self):
10052 
    return
10053 
 
10054 
 
10055 
  def __repr__(self):
10056 
    L = ['%s=%r' % (key, value)
10057 
      for key, value in self.__dict__.iteritems()]
10058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10059 
 
10060 
  def __eq__(self, other):
10061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10062 
 
10063 
  def __ne__(self, other):
10064 
    return not (self == other)
10065 
 
6512 kshitij.so 10066 
class addTag_args:
10067 
  """
10068 
  Attributes:
10069 
   - displayName
10070 
   - itemId
10071 
  """
10072 
 
10073 
  thrift_spec = (
10074 
    None, # 0
10075 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10076 
    (2, TType.I64, 'itemId', None, None, ), # 2
10077 
  )
10078 
 
10079 
  def __init__(self, displayName=None, itemId=None,):
10080 
    self.displayName = displayName
10081 
    self.itemId = itemId
10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
10092 
      if fid == 1:
10093 
        if ftype == TType.STRING:
10094 
          self.displayName = iprot.readString();
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      elif fid == 2:
10098 
        if ftype == TType.I64:
10099 
          self.itemId = iprot.readI64();
10100 
        else:
10101 
          iprot.skip(ftype)
10102 
      else:
10103 
        iprot.skip(ftype)
10104 
      iprot.readFieldEnd()
10105 
    iprot.readStructEnd()
10106 
 
10107 
  def write(self, oprot):
10108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10110 
      return
10111 
    oprot.writeStructBegin('addTag_args')
10112 
    if self.displayName is not None:
10113 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10114 
      oprot.writeString(self.displayName)
10115 
      oprot.writeFieldEnd()
10116 
    if self.itemId is not None:
10117 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10118 
      oprot.writeI64(self.itemId)
10119 
      oprot.writeFieldEnd()
10120 
    oprot.writeFieldStop()
10121 
    oprot.writeStructEnd()
10122 
 
10123 
  def validate(self):
10124 
    return
10125 
 
10126 
 
10127 
  def __repr__(self):
10128 
    L = ['%s=%r' % (key, value)
10129 
      for key, value in self.__dict__.iteritems()]
10130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10131 
 
10132 
  def __eq__(self, other):
10133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10134 
 
10135 
  def __ne__(self, other):
10136 
    return not (self == other)
10137 
 
10138 
class addTag_result:
10139 
  """
10140 
  Attributes:
10141 
   - success
10142 
  """
10143 
 
10144 
  thrift_spec = (
10145 
    (0, TType.BOOL, 'success', None, None, ), # 0
10146 
  )
10147 
 
10148 
  def __init__(self, success=None,):
10149 
    self.success = success
10150 
 
10151 
  def read(self, iprot):
10152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10154 
      return
10155 
    iprot.readStructBegin()
10156 
    while True:
10157 
      (fname, ftype, fid) = iprot.readFieldBegin()
10158 
      if ftype == TType.STOP:
10159 
        break
10160 
      if fid == 0:
10161 
        if ftype == TType.BOOL:
10162 
          self.success = iprot.readBool();
10163 
        else:
10164 
          iprot.skip(ftype)
10165 
      else:
10166 
        iprot.skip(ftype)
10167 
      iprot.readFieldEnd()
10168 
    iprot.readStructEnd()
10169 
 
10170 
  def write(self, oprot):
10171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10173 
      return
10174 
    oprot.writeStructBegin('addTag_result')
10175 
    if self.success is not None:
10176 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10177 
      oprot.writeBool(self.success)
10178 
      oprot.writeFieldEnd()
10179 
    oprot.writeFieldStop()
10180 
    oprot.writeStructEnd()
10181 
 
10182 
  def validate(self):
10183 
    return
10184 
 
10185 
 
10186 
  def __repr__(self):
10187 
    L = ['%s=%r' % (key, value)
10188 
      for key, value in self.__dict__.iteritems()]
10189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10190 
 
10191 
  def __eq__(self, other):
10192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10193 
 
10194 
  def __ne__(self, other):
10195 
    return not (self == other)
10196 
 
10197 
class deleteEntityTag_args:
10198 
  """
10199 
  Attributes:
10200 
   - displayName
10201 
   - itemId
10202 
  """
10203 
 
10204 
  thrift_spec = (
10205 
    None, # 0
10206 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10207 
    (2, TType.I64, 'itemId', None, None, ), # 2
10208 
  )
10209 
 
10210 
  def __init__(self, displayName=None, itemId=None,):
10211 
    self.displayName = displayName
10212 
    self.itemId = itemId
10213 
 
10214 
  def read(self, iprot):
10215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10217 
      return
10218 
    iprot.readStructBegin()
10219 
    while True:
10220 
      (fname, ftype, fid) = iprot.readFieldBegin()
10221 
      if ftype == TType.STOP:
10222 
        break
10223 
      if fid == 1:
10224 
        if ftype == TType.STRING:
10225 
          self.displayName = iprot.readString();
10226 
        else:
10227 
          iprot.skip(ftype)
10228 
      elif fid == 2:
10229 
        if ftype == TType.I64:
10230 
          self.itemId = iprot.readI64();
10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      else:
10234 
        iprot.skip(ftype)
10235 
      iprot.readFieldEnd()
10236 
    iprot.readStructEnd()
10237 
 
10238 
  def write(self, oprot):
10239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10241 
      return
10242 
    oprot.writeStructBegin('deleteEntityTag_args')
10243 
    if self.displayName is not None:
10244 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10245 
      oprot.writeString(self.displayName)
10246 
      oprot.writeFieldEnd()
10247 
    if self.itemId is not None:
10248 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10249 
      oprot.writeI64(self.itemId)
10250 
      oprot.writeFieldEnd()
10251 
    oprot.writeFieldStop()
10252 
    oprot.writeStructEnd()
10253 
 
10254 
  def validate(self):
10255 
    return
10256 
 
10257 
 
10258 
  def __repr__(self):
10259 
    L = ['%s=%r' % (key, value)
10260 
      for key, value in self.__dict__.iteritems()]
10261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10262 
 
10263 
  def __eq__(self, other):
10264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10265 
 
10266 
  def __ne__(self, other):
10267 
    return not (self == other)
10268 
 
10269 
class deleteEntityTag_result:
10270 
  """
10271 
  Attributes:
10272 
   - success
10273 
  """
10274 
 
10275 
  thrift_spec = (
10276 
    (0, TType.BOOL, 'success', None, None, ), # 0
10277 
  )
10278 
 
10279 
  def __init__(self, success=None,):
10280 
    self.success = success
10281 
 
10282 
  def read(self, iprot):
10283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10285 
      return
10286 
    iprot.readStructBegin()
10287 
    while True:
10288 
      (fname, ftype, fid) = iprot.readFieldBegin()
10289 
      if ftype == TType.STOP:
10290 
        break
10291 
      if fid == 0:
10292 
        if ftype == TType.BOOL:
10293 
          self.success = iprot.readBool();
10294 
        else:
10295 
          iprot.skip(ftype)
10296 
      else:
10297 
        iprot.skip(ftype)
10298 
      iprot.readFieldEnd()
10299 
    iprot.readStructEnd()
10300 
 
10301 
  def write(self, oprot):
10302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10304 
      return
10305 
    oprot.writeStructBegin('deleteEntityTag_result')
10306 
    if self.success is not None:
10307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10308 
      oprot.writeBool(self.success)
10309 
      oprot.writeFieldEnd()
10310 
    oprot.writeFieldStop()
10311 
    oprot.writeStructEnd()
10312 
 
10313 
  def validate(self):
10314 
    return
10315 
 
10316 
 
10317 
  def __repr__(self):
10318 
    L = ['%s=%r' % (key, value)
10319 
      for key, value in self.__dict__.iteritems()]
10320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10321 
 
10322 
  def __eq__(self, other):
10323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10324 
 
10325 
  def __ne__(self, other):
10326 
    return not (self == other)
10327 
 
10328 
class deleteTag_args:
10329 
  """
10330 
  Attributes:
10331 
   - displayName
10332 
  """
10333 
 
10334 
  thrift_spec = (
10335 
    None, # 0
10336 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10337 
  )
10338 
 
10339 
  def __init__(self, displayName=None,):
10340 
    self.displayName = displayName
10341 
 
10342 
  def read(self, iprot):
10343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10345 
      return
10346 
    iprot.readStructBegin()
10347 
    while True:
10348 
      (fname, ftype, fid) = iprot.readFieldBegin()
10349 
      if ftype == TType.STOP:
10350 
        break
10351 
      if fid == 1:
10352 
        if ftype == TType.STRING:
10353 
          self.displayName = iprot.readString();
10354 
        else:
10355 
          iprot.skip(ftype)
10356 
      else:
10357 
        iprot.skip(ftype)
10358 
      iprot.readFieldEnd()
10359 
    iprot.readStructEnd()
10360 
 
10361 
  def write(self, oprot):
10362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10364 
      return
10365 
    oprot.writeStructBegin('deleteTag_args')
10366 
    if self.displayName is not None:
10367 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10368 
      oprot.writeString(self.displayName)
10369 
      oprot.writeFieldEnd()
10370 
    oprot.writeFieldStop()
10371 
    oprot.writeStructEnd()
10372 
 
10373 
  def validate(self):
10374 
    return
10375 
 
10376 
 
10377 
  def __repr__(self):
10378 
    L = ['%s=%r' % (key, value)
10379 
      for key, value in self.__dict__.iteritems()]
10380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10381 
 
10382 
  def __eq__(self, other):
10383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10384 
 
10385 
  def __ne__(self, other):
10386 
    return not (self == other)
10387 
 
10388 
class deleteTag_result:
10389 
  """
10390 
  Attributes:
10391 
   - success
10392 
  """
10393 
 
10394 
  thrift_spec = (
10395 
    (0, TType.BOOL, 'success', None, None, ), # 0
10396 
  )
10397 
 
10398 
  def __init__(self, success=None,):
10399 
    self.success = success
10400 
 
10401 
  def read(self, iprot):
10402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10404 
      return
10405 
    iprot.readStructBegin()
10406 
    while True:
10407 
      (fname, ftype, fid) = iprot.readFieldBegin()
10408 
      if ftype == TType.STOP:
10409 
        break
10410 
      if fid == 0:
10411 
        if ftype == TType.BOOL:
10412 
          self.success = iprot.readBool();
10413 
        else:
10414 
          iprot.skip(ftype)
10415 
      else:
10416 
        iprot.skip(ftype)
10417 
      iprot.readFieldEnd()
10418 
    iprot.readStructEnd()
10419 
 
10420 
  def write(self, oprot):
10421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10423 
      return
10424 
    oprot.writeStructBegin('deleteTag_result')
10425 
    if self.success is not None:
10426 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10427 
      oprot.writeBool(self.success)
10428 
      oprot.writeFieldEnd()
10429 
    oprot.writeFieldStop()
10430 
    oprot.writeStructEnd()
10431 
 
10432 
  def validate(self):
10433 
    return
10434 
 
10435 
 
10436 
  def __repr__(self):
10437 
    L = ['%s=%r' % (key, value)
10438 
      for key, value in self.__dict__.iteritems()]
10439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10440 
 
10441 
  def __eq__(self, other):
10442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10443 
 
10444 
  def __ne__(self, other):
10445 
    return not (self == other)
10446 
 
10447 
class getAllTags_args:
10448 
 
10449 
  thrift_spec = (
10450 
  )
10451 
 
10452 
  def read(self, iprot):
10453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10455 
      return
10456 
    iprot.readStructBegin()
10457 
    while True:
10458 
      (fname, ftype, fid) = iprot.readFieldBegin()
10459 
      if ftype == TType.STOP:
10460 
        break
10461 
      else:
10462 
        iprot.skip(ftype)
10463 
      iprot.readFieldEnd()
10464 
    iprot.readStructEnd()
10465 
 
10466 
  def write(self, oprot):
10467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10469 
      return
10470 
    oprot.writeStructBegin('getAllTags_args')
10471 
    oprot.writeFieldStop()
10472 
    oprot.writeStructEnd()
10473 
 
10474 
  def validate(self):
10475 
    return
10476 
 
10477 
 
10478 
  def __repr__(self):
10479 
    L = ['%s=%r' % (key, value)
10480 
      for key, value in self.__dict__.iteritems()]
10481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10482 
 
10483 
  def __eq__(self, other):
10484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10485 
 
10486 
  def __ne__(self, other):
10487 
    return not (self == other)
10488 
 
10489 
class getAllTags_result:
10490 
  """
10491 
  Attributes:
10492 
   - success
10493 
  """
10494 
 
10495 
  thrift_spec = (
10496 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10497 
  )
10498 
 
10499 
  def __init__(self, success=None,):
10500 
    self.success = success
10501 
 
10502 
  def read(self, iprot):
10503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10505 
      return
10506 
    iprot.readStructBegin()
10507 
    while True:
10508 
      (fname, ftype, fid) = iprot.readFieldBegin()
10509 
      if ftype == TType.STOP:
10510 
        break
10511 
      if fid == 0:
10512 
        if ftype == TType.LIST:
10513 
          self.success = []
7438 amit.gupta 10514 
          (_etype154, _size151) = iprot.readListBegin()
10515 
          for _i155 in xrange(_size151):
10516 
            _elem156 = iprot.readString();
10517 
            self.success.append(_elem156)
6512 kshitij.so 10518 
          iprot.readListEnd()
10519 
        else:
10520 
          iprot.skip(ftype)
10521 
      else:
10522 
        iprot.skip(ftype)
10523 
      iprot.readFieldEnd()
10524 
    iprot.readStructEnd()
10525 
 
10526 
  def write(self, oprot):
10527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10529 
      return
10530 
    oprot.writeStructBegin('getAllTags_result')
10531 
    if self.success is not None:
10532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10533 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10534 
      for iter157 in self.success:
10535 
        oprot.writeString(iter157)
6512 kshitij.so 10536 
      oprot.writeListEnd()
10537 
      oprot.writeFieldEnd()
10538 
    oprot.writeFieldStop()
10539 
    oprot.writeStructEnd()
10540 
 
10541 
  def validate(self):
10542 
    return
10543 
 
10544 
 
10545 
  def __repr__(self):
10546 
    L = ['%s=%r' % (key, value)
10547 
      for key, value in self.__dict__.iteritems()]
10548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10549 
 
10550 
  def __eq__(self, other):
10551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10552 
 
10553 
  def __ne__(self, other):
10554 
    return not (self == other)
10555 
 
10556 
class getAllEntitiesByTagName_args:
10557 
  """
10558 
  Attributes:
10559 
   - displayName
10560 
  """
10561 
 
10562 
  thrift_spec = (
10563 
    None, # 0
10564 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10565 
  )
10566 
 
10567 
  def __init__(self, displayName=None,):
10568 
    self.displayName = displayName
10569 
 
10570 
  def read(self, iprot):
10571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10573 
      return
10574 
    iprot.readStructBegin()
10575 
    while True:
10576 
      (fname, ftype, fid) = iprot.readFieldBegin()
10577 
      if ftype == TType.STOP:
10578 
        break
10579 
      if fid == 1:
10580 
        if ftype == TType.STRING:
10581 
          self.displayName = iprot.readString();
10582 
        else:
10583 
          iprot.skip(ftype)
10584 
      else:
10585 
        iprot.skip(ftype)
10586 
      iprot.readFieldEnd()
10587 
    iprot.readStructEnd()
10588 
 
10589 
  def write(self, oprot):
10590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10592 
      return
10593 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10594 
    if self.displayName is not None:
10595 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10596 
      oprot.writeString(self.displayName)
10597 
      oprot.writeFieldEnd()
10598 
    oprot.writeFieldStop()
10599 
    oprot.writeStructEnd()
10600 
 
10601 
  def validate(self):
10602 
    return
10603 
 
10604 
 
10605 
  def __repr__(self):
10606 
    L = ['%s=%r' % (key, value)
10607 
      for key, value in self.__dict__.iteritems()]
10608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10609 
 
10610 
  def __eq__(self, other):
10611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10612 
 
10613 
  def __ne__(self, other):
10614 
    return not (self == other)
10615 
 
10616 
class getAllEntitiesByTagName_result:
10617 
  """
10618 
  Attributes:
10619 
   - success
10620 
  """
10621 
 
10622 
  thrift_spec = (
10623 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10624 
  )
10625 
 
10626 
  def __init__(self, success=None,):
10627 
    self.success = success
10628 
 
10629 
  def read(self, iprot):
10630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10632 
      return
10633 
    iprot.readStructBegin()
10634 
    while True:
10635 
      (fname, ftype, fid) = iprot.readFieldBegin()
10636 
      if ftype == TType.STOP:
10637 
        break
10638 
      if fid == 0:
10639 
        if ftype == TType.LIST:
10640 
          self.success = []
7438 amit.gupta 10641 
          (_etype161, _size158) = iprot.readListBegin()
10642 
          for _i162 in xrange(_size158):
10643 
            _elem163 = iprot.readI64();
10644 
            self.success.append(_elem163)
6512 kshitij.so 10645 
          iprot.readListEnd()
10646 
        else:
10647 
          iprot.skip(ftype)
10648 
      else:
10649 
        iprot.skip(ftype)
10650 
      iprot.readFieldEnd()
10651 
    iprot.readStructEnd()
10652 
 
10653 
  def write(self, oprot):
10654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10656 
      return
10657 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10658 
    if self.success is not None:
10659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10660 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10661 
      for iter164 in self.success:
10662 
        oprot.writeI64(iter164)
6512 kshitij.so 10663 
      oprot.writeListEnd()
10664 
      oprot.writeFieldEnd()
10665 
    oprot.writeFieldStop()
10666 
    oprot.writeStructEnd()
10667 
 
10668 
  def validate(self):
10669 
    return
10670 
 
10671 
 
10672 
  def __repr__(self):
10673 
    L = ['%s=%r' % (key, value)
10674 
      for key, value in self.__dict__.iteritems()]
10675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10676 
 
10677 
  def __eq__(self, other):
10678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10679 
 
10680 
  def __ne__(self, other):
10681 
    return not (self == other)
10682 
 
6845 amit.gupta 10683 
class getAllEntityTags_args:
10684 
 
10685 
  thrift_spec = (
10686 
  )
10687 
 
10688 
  def read(self, iprot):
10689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10691 
      return
10692 
    iprot.readStructBegin()
10693 
    while True:
10694 
      (fname, ftype, fid) = iprot.readFieldBegin()
10695 
      if ftype == TType.STOP:
10696 
        break
10697 
      else:
10698 
        iprot.skip(ftype)
10699 
      iprot.readFieldEnd()
10700 
    iprot.readStructEnd()
10701 
 
10702 
  def write(self, oprot):
10703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10705 
      return
10706 
    oprot.writeStructBegin('getAllEntityTags_args')
10707 
    oprot.writeFieldStop()
10708 
    oprot.writeStructEnd()
10709 
 
10710 
  def validate(self):
10711 
    return
10712 
 
10713 
 
10714 
  def __repr__(self):
10715 
    L = ['%s=%r' % (key, value)
10716 
      for key, value in self.__dict__.iteritems()]
10717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10718 
 
10719 
  def __eq__(self, other):
10720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10721 
 
10722 
  def __ne__(self, other):
10723 
    return not (self == other)
10724 
 
10725 
class getAllEntityTags_result:
10726 
  """
10727 
  Attributes:
10728 
   - success
10729 
  """
10730 
 
10731 
  thrift_spec = (
10732 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10733 
  )
10734 
 
10735 
  def __init__(self, success=None,):
10736 
    self.success = success
10737 
 
10738 
  def read(self, iprot):
10739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10741 
      return
10742 
    iprot.readStructBegin()
10743 
    while True:
10744 
      (fname, ftype, fid) = iprot.readFieldBegin()
10745 
      if ftype == TType.STOP:
10746 
        break
10747 
      if fid == 0:
10748 
        if ftype == TType.MAP:
10749 
          self.success = {}
7438 amit.gupta 10750 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10751 
          for _i169 in xrange(_size165):
10752 
            _key170 = iprot.readI64();
10753 
            _val171 = []
10754 
            (_etype175, _size172) = iprot.readListBegin()
10755 
            for _i176 in xrange(_size172):
10756 
              _elem177 = iprot.readString();
10757 
              _val171.append(_elem177)
6845 amit.gupta 10758 
            iprot.readListEnd()
7438 amit.gupta 10759 
            self.success[_key170] = _val171
6845 amit.gupta 10760 
          iprot.readMapEnd()
10761 
        else:
10762 
          iprot.skip(ftype)
10763 
      else:
10764 
        iprot.skip(ftype)
10765 
      iprot.readFieldEnd()
10766 
    iprot.readStructEnd()
10767 
 
10768 
  def write(self, oprot):
10769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10771 
      return
10772 
    oprot.writeStructBegin('getAllEntityTags_result')
10773 
    if self.success is not None:
10774 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10775 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10776 
      for kiter178,viter179 in self.success.items():
10777 
        oprot.writeI64(kiter178)
10778 
        oprot.writeListBegin(TType.STRING, len(viter179))
10779 
        for iter180 in viter179:
10780 
          oprot.writeString(iter180)
6845 amit.gupta 10781 
        oprot.writeListEnd()
10782 
      oprot.writeMapEnd()
10783 
      oprot.writeFieldEnd()
10784 
    oprot.writeFieldStop()
10785 
    oprot.writeStructEnd()
10786 
 
10787 
  def validate(self):
10788 
    return
10789 
 
10790 
 
10791 
  def __repr__(self):
10792 
    L = ['%s=%r' % (key, value)
10793 
      for key, value in self.__dict__.iteritems()]
10794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10795 
 
10796 
  def __eq__(self, other):
10797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10798 
 
10799 
  def __ne__(self, other):
10800 
    return not (self == other)
10801 
 
6850 kshitij.so 10802 
class addBanner_args:
10803 
  """
10804 
  Attributes:
10805 
   - bannerName
10806 
   - imageName
10807 
   - link
10808 
   - priority
10809 
   - isActive
10810 
   - hasMap
10811 
  """
10812 
 
10813 
  thrift_spec = (
10814 
    None, # 0
10815 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10816 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10817 
    (3, TType.STRING, 'link', None, None, ), # 3
10818 
    (4, TType.I64, 'priority', None, None, ), # 4
10819 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10820 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10821 
  )
10822 
 
10823 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10824 
    self.bannerName = bannerName
10825 
    self.imageName = imageName
10826 
    self.link = link
10827 
    self.priority = priority
10828 
    self.isActive = isActive
10829 
    self.hasMap = hasMap
10830 
 
10831 
  def read(self, iprot):
10832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10834 
      return
10835 
    iprot.readStructBegin()
10836 
    while True:
10837 
      (fname, ftype, fid) = iprot.readFieldBegin()
10838 
      if ftype == TType.STOP:
10839 
        break
10840 
      if fid == 1:
10841 
        if ftype == TType.STRING:
10842 
          self.bannerName = iprot.readString();
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      elif fid == 2:
10846 
        if ftype == TType.STRING:
10847 
          self.imageName = iprot.readString();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      elif fid == 3:
10851 
        if ftype == TType.STRING:
10852 
          self.link = iprot.readString();
10853 
        else:
10854 
          iprot.skip(ftype)
10855 
      elif fid == 4:
10856 
        if ftype == TType.I64:
10857 
          self.priority = iprot.readI64();
10858 
        else:
10859 
          iprot.skip(ftype)
10860 
      elif fid == 5:
10861 
        if ftype == TType.BOOL:
10862 
          self.isActive = iprot.readBool();
10863 
        else:
10864 
          iprot.skip(ftype)
10865 
      elif fid == 6:
10866 
        if ftype == TType.BOOL:
10867 
          self.hasMap = iprot.readBool();
10868 
        else:
10869 
          iprot.skip(ftype)
10870 
      else:
10871 
        iprot.skip(ftype)
10872 
      iprot.readFieldEnd()
10873 
    iprot.readStructEnd()
10874 
 
10875 
  def write(self, oprot):
10876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10878 
      return
10879 
    oprot.writeStructBegin('addBanner_args')
10880 
    if self.bannerName is not None:
10881 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10882 
      oprot.writeString(self.bannerName)
10883 
      oprot.writeFieldEnd()
10884 
    if self.imageName is not None:
10885 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10886 
      oprot.writeString(self.imageName)
10887 
      oprot.writeFieldEnd()
10888 
    if self.link is not None:
10889 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10890 
      oprot.writeString(self.link)
10891 
      oprot.writeFieldEnd()
10892 
    if self.priority is not None:
10893 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10894 
      oprot.writeI64(self.priority)
10895 
      oprot.writeFieldEnd()
10896 
    if self.isActive is not None:
10897 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10898 
      oprot.writeBool(self.isActive)
10899 
      oprot.writeFieldEnd()
10900 
    if self.hasMap is not None:
10901 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10902 
      oprot.writeBool(self.hasMap)
10903 
      oprot.writeFieldEnd()
10904 
    oprot.writeFieldStop()
10905 
    oprot.writeStructEnd()
10906 
 
10907 
  def validate(self):
10908 
    return
10909 
 
10910 
 
10911 
  def __repr__(self):
10912 
    L = ['%s=%r' % (key, value)
10913 
      for key, value in self.__dict__.iteritems()]
10914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10915 
 
10916 
  def __eq__(self, other):
10917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10918 
 
10919 
  def __ne__(self, other):
10920 
    return not (self == other)
10921 
 
10922 
class addBanner_result:
10923 
  """
10924 
  Attributes:
10925 
   - success
10926 
  """
10927 
 
10928 
  thrift_spec = (
10929 
    (0, TType.BOOL, 'success', None, None, ), # 0
10930 
  )
10931 
 
10932 
  def __init__(self, success=None,):
10933 
    self.success = success
10934 
 
10935 
  def read(self, iprot):
10936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10938 
      return
10939 
    iprot.readStructBegin()
10940 
    while True:
10941 
      (fname, ftype, fid) = iprot.readFieldBegin()
10942 
      if ftype == TType.STOP:
10943 
        break
10944 
      if fid == 0:
10945 
        if ftype == TType.BOOL:
10946 
          self.success = iprot.readBool();
10947 
        else:
10948 
          iprot.skip(ftype)
10949 
      else:
10950 
        iprot.skip(ftype)
10951 
      iprot.readFieldEnd()
10952 
    iprot.readStructEnd()
10953 
 
10954 
  def write(self, oprot):
10955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10957 
      return
10958 
    oprot.writeStructBegin('addBanner_result')
10959 
    if self.success is not None:
10960 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10961 
      oprot.writeBool(self.success)
10962 
      oprot.writeFieldEnd()
10963 
    oprot.writeFieldStop()
10964 
    oprot.writeStructEnd()
10965 
 
10966 
  def validate(self):
10967 
    return
10968 
 
10969 
 
10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
10981 
class getAllBanners_args:
10982 
 
10983 
  thrift_spec = (
10984 
  )
10985 
 
10986 
  def read(self, iprot):
10987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10989 
      return
10990 
    iprot.readStructBegin()
10991 
    while True:
10992 
      (fname, ftype, fid) = iprot.readFieldBegin()
10993 
      if ftype == TType.STOP:
10994 
        break
10995 
      else:
10996 
        iprot.skip(ftype)
10997 
      iprot.readFieldEnd()
10998 
    iprot.readStructEnd()
10999 
 
11000 
  def write(self, oprot):
11001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11003 
      return
11004 
    oprot.writeStructBegin('getAllBanners_args')
11005 
    oprot.writeFieldStop()
11006 
    oprot.writeStructEnd()
11007 
 
11008 
  def validate(self):
11009 
    return
11010 
 
11011 
 
11012 
  def __repr__(self):
11013 
    L = ['%s=%r' % (key, value)
11014 
      for key, value in self.__dict__.iteritems()]
11015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11016 
 
11017 
  def __eq__(self, other):
11018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11019 
 
11020 
  def __ne__(self, other):
11021 
    return not (self == other)
11022 
 
11023 
class getAllBanners_result:
11024 
  """
11025 
  Attributes:
11026 
   - success
11027 
  """
11028 
 
11029 
  thrift_spec = (
11030 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11031 
  )
11032 
 
11033 
  def __init__(self, success=None,):
11034 
    self.success = success
11035 
 
11036 
  def read(self, iprot):
11037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11039 
      return
11040 
    iprot.readStructBegin()
11041 
    while True:
11042 
      (fname, ftype, fid) = iprot.readFieldBegin()
11043 
      if ftype == TType.STOP:
11044 
        break
11045 
      if fid == 0:
11046 
        if ftype == TType.LIST:
11047 
          self.success = []
7438 amit.gupta 11048 
          (_etype184, _size181) = iprot.readListBegin()
11049 
          for _i185 in xrange(_size181):
11050 
            _elem186 = iprot.readString();
11051 
            self.success.append(_elem186)
6850 kshitij.so 11052 
          iprot.readListEnd()
11053 
        else:
11054 
          iprot.skip(ftype)
11055 
      else:
11056 
        iprot.skip(ftype)
11057 
      iprot.readFieldEnd()
11058 
    iprot.readStructEnd()
11059 
 
11060 
  def write(self, oprot):
11061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11063 
      return
11064 
    oprot.writeStructBegin('getAllBanners_result')
11065 
    if self.success is not None:
11066 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11067 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11068 
      for iter187 in self.success:
11069 
        oprot.writeString(iter187)
6850 kshitij.so 11070 
      oprot.writeListEnd()
11071 
      oprot.writeFieldEnd()
11072 
    oprot.writeFieldStop()
11073 
    oprot.writeStructEnd()
11074 
 
11075 
  def validate(self):
11076 
    return
11077 
 
11078 
 
11079 
  def __repr__(self):
11080 
    L = ['%s=%r' % (key, value)
11081 
      for key, value in self.__dict__.iteritems()]
11082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11083 
 
11084 
  def __eq__(self, other):
11085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11086 
 
11087 
  def __ne__(self, other):
11088 
    return not (self == other)
11089 
 
11090 
class deleteBanner_args:
11091 
  """
11092 
  Attributes:
11093 
   - bannerName
11094 
  """
11095 
 
11096 
  thrift_spec = (
11097 
    None, # 0
11098 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11099 
  )
11100 
 
11101 
  def __init__(self, bannerName=None,):
11102 
    self.bannerName = bannerName
11103 
 
11104 
  def read(self, iprot):
11105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11107 
      return
11108 
    iprot.readStructBegin()
11109 
    while True:
11110 
      (fname, ftype, fid) = iprot.readFieldBegin()
11111 
      if ftype == TType.STOP:
11112 
        break
11113 
      if fid == 1:
11114 
        if ftype == TType.STRING:
11115 
          self.bannerName = iprot.readString();
11116 
        else:
11117 
          iprot.skip(ftype)
11118 
      else:
11119 
        iprot.skip(ftype)
11120 
      iprot.readFieldEnd()
11121 
    iprot.readStructEnd()
11122 
 
11123 
  def write(self, oprot):
11124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11126 
      return
11127 
    oprot.writeStructBegin('deleteBanner_args')
11128 
    if self.bannerName is not None:
11129 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11130 
      oprot.writeString(self.bannerName)
11131 
      oprot.writeFieldEnd()
11132 
    oprot.writeFieldStop()
11133 
    oprot.writeStructEnd()
11134 
 
11135 
  def validate(self):
11136 
    return
11137 
 
11138 
 
11139 
  def __repr__(self):
11140 
    L = ['%s=%r' % (key, value)
11141 
      for key, value in self.__dict__.iteritems()]
11142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11143 
 
11144 
  def __eq__(self, other):
11145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11146 
 
11147 
  def __ne__(self, other):
11148 
    return not (self == other)
11149 
 
11150 
class deleteBanner_result:
11151 
  """
11152 
  Attributes:
11153 
   - success
11154 
  """
11155 
 
11156 
  thrift_spec = (
11157 
    (0, TType.BOOL, 'success', None, None, ), # 0
11158 
  )
11159 
 
11160 
  def __init__(self, success=None,):
11161 
    self.success = success
11162 
 
11163 
  def read(self, iprot):
11164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11166 
      return
11167 
    iprot.readStructBegin()
11168 
    while True:
11169 
      (fname, ftype, fid) = iprot.readFieldBegin()
11170 
      if ftype == TType.STOP:
11171 
        break
11172 
      if fid == 0:
11173 
        if ftype == TType.BOOL:
11174 
          self.success = iprot.readBool();
11175 
        else:
11176 
          iprot.skip(ftype)
11177 
      else:
11178 
        iprot.skip(ftype)
11179 
      iprot.readFieldEnd()
11180 
    iprot.readStructEnd()
11181 
 
11182 
  def write(self, oprot):
11183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11185 
      return
11186 
    oprot.writeStructBegin('deleteBanner_result')
11187 
    if self.success is not None:
11188 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11189 
      oprot.writeBool(self.success)
11190 
      oprot.writeFieldEnd()
11191 
    oprot.writeFieldStop()
11192 
    oprot.writeStructEnd()
11193 
 
11194 
  def validate(self):
11195 
    return
11196 
 
11197 
 
11198 
  def __repr__(self):
11199 
    L = ['%s=%r' % (key, value)
11200 
      for key, value in self.__dict__.iteritems()]
11201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11202 
 
11203 
  def __eq__(self, other):
11204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11205 
 
11206 
  def __ne__(self, other):
11207 
    return not (self == other)
11208 
 
11209 
class getBannerDetails_args:
11210 
  """
11211 
  Attributes:
11212 
   - bannerName
11213 
  """
11214 
 
11215 
  thrift_spec = (
11216 
    None, # 0
11217 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11218 
  )
11219 
 
11220 
  def __init__(self, bannerName=None,):
11221 
    self.bannerName = bannerName
11222 
 
11223 
  def read(self, iprot):
11224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11226 
      return
11227 
    iprot.readStructBegin()
11228 
    while True:
11229 
      (fname, ftype, fid) = iprot.readFieldBegin()
11230 
      if ftype == TType.STOP:
11231 
        break
11232 
      if fid == 1:
11233 
        if ftype == TType.STRING:
11234 
          self.bannerName = iprot.readString();
11235 
        else:
11236 
          iprot.skip(ftype)
11237 
      else:
11238 
        iprot.skip(ftype)
11239 
      iprot.readFieldEnd()
11240 
    iprot.readStructEnd()
11241 
 
11242 
  def write(self, oprot):
11243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11245 
      return
11246 
    oprot.writeStructBegin('getBannerDetails_args')
11247 
    if self.bannerName is not None:
11248 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11249 
      oprot.writeString(self.bannerName)
11250 
      oprot.writeFieldEnd()
11251 
    oprot.writeFieldStop()
11252 
    oprot.writeStructEnd()
11253 
 
11254 
  def validate(self):
11255 
    return
11256 
 
11257 
 
11258 
  def __repr__(self):
11259 
    L = ['%s=%r' % (key, value)
11260 
      for key, value in self.__dict__.iteritems()]
11261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11262 
 
11263 
  def __eq__(self, other):
11264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11265 
 
11266 
  def __ne__(self, other):
11267 
    return not (self == other)
11268 
 
11269 
class getBannerDetails_result:
11270 
  """
11271 
  Attributes:
11272 
   - success
11273 
  """
11274 
 
11275 
  thrift_spec = (
11276 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11277 
  )
11278 
 
11279 
  def __init__(self, success=None,):
11280 
    self.success = success
11281 
 
11282 
  def read(self, iprot):
11283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11285 
      return
11286 
    iprot.readStructBegin()
11287 
    while True:
11288 
      (fname, ftype, fid) = iprot.readFieldBegin()
11289 
      if ftype == TType.STOP:
11290 
        break
11291 
      if fid == 0:
11292 
        if ftype == TType.STRUCT:
11293 
          self.success = Banner()
11294 
          self.success.read(iprot)
11295 
        else:
11296 
          iprot.skip(ftype)
11297 
      else:
11298 
        iprot.skip(ftype)
11299 
      iprot.readFieldEnd()
11300 
    iprot.readStructEnd()
11301 
 
11302 
  def write(self, oprot):
11303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11305 
      return
11306 
    oprot.writeStructBegin('getBannerDetails_result')
11307 
    if self.success is not None:
11308 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11309 
      self.success.write(oprot)
11310 
      oprot.writeFieldEnd()
11311 
    oprot.writeFieldStop()
11312 
    oprot.writeStructEnd()
11313 
 
11314 
  def validate(self):
11315 
    return
11316 
 
11317 
 
11318 
  def __repr__(self):
11319 
    L = ['%s=%r' % (key, value)
11320 
      for key, value in self.__dict__.iteritems()]
11321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11322 
 
11323 
  def __eq__(self, other):
11324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11325 
 
11326 
  def __ne__(self, other):
11327 
    return not (self == other)
11328 
 
11329 
class getActiveBanners_args:
11330 
 
11331 
  thrift_spec = (
11332 
  )
11333 
 
11334 
  def read(self, iprot):
11335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11337 
      return
11338 
    iprot.readStructBegin()
11339 
    while True:
11340 
      (fname, ftype, fid) = iprot.readFieldBegin()
11341 
      if ftype == TType.STOP:
11342 
        break
11343 
      else:
11344 
        iprot.skip(ftype)
11345 
      iprot.readFieldEnd()
11346 
    iprot.readStructEnd()
11347 
 
11348 
  def write(self, oprot):
11349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11351 
      return
11352 
    oprot.writeStructBegin('getActiveBanners_args')
11353 
    oprot.writeFieldStop()
11354 
    oprot.writeStructEnd()
11355 
 
11356 
  def validate(self):
11357 
    return
11358 
 
11359 
 
11360 
  def __repr__(self):
11361 
    L = ['%s=%r' % (key, value)
11362 
      for key, value in self.__dict__.iteritems()]
11363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11364 
 
11365 
  def __eq__(self, other):
11366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11367 
 
11368 
  def __ne__(self, other):
11369 
    return not (self == other)
11370 
 
11371 
class getActiveBanners_result:
11372 
  """
11373 
  Attributes:
11374 
   - success
11375 
  """
11376 
 
11377 
  thrift_spec = (
11378 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11379 
  )
11380 
 
11381 
  def __init__(self, success=None,):
11382 
    self.success = success
11383 
 
11384 
  def read(self, iprot):
11385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11387 
      return
11388 
    iprot.readStructBegin()
11389 
    while True:
11390 
      (fname, ftype, fid) = iprot.readFieldBegin()
11391 
      if ftype == TType.STOP:
11392 
        break
11393 
      if fid == 0:
11394 
        if ftype == TType.LIST:
11395 
          self.success = []
7438 amit.gupta 11396 
          (_etype191, _size188) = iprot.readListBegin()
11397 
          for _i192 in xrange(_size188):
11398 
            _elem193 = Banner()
11399 
            _elem193.read(iprot)
11400 
            self.success.append(_elem193)
6850 kshitij.so 11401 
          iprot.readListEnd()
11402 
        else:
11403 
          iprot.skip(ftype)
11404 
      else:
11405 
        iprot.skip(ftype)
11406 
      iprot.readFieldEnd()
11407 
    iprot.readStructEnd()
11408 
 
11409 
  def write(self, oprot):
11410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11412 
      return
11413 
    oprot.writeStructBegin('getActiveBanners_result')
11414 
    if self.success is not None:
11415 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11416 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11417 
      for iter194 in self.success:
11418 
        iter194.write(oprot)
6850 kshitij.so 11419 
      oprot.writeListEnd()
11420 
      oprot.writeFieldEnd()
11421 
    oprot.writeFieldStop()
11422 
    oprot.writeStructEnd()
11423 
 
11424 
  def validate(self):
11425 
    return
11426 
 
11427 
 
11428 
  def __repr__(self):
11429 
    L = ['%s=%r' % (key, value)
11430 
      for key, value in self.__dict__.iteritems()]
11431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11432 
 
11433 
  def __eq__(self, other):
11434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11435 
 
11436 
  def __ne__(self, other):
11437 
    return not (self == other)
11438 
 
6849 kshitij.so 11439 
class addBannerMap_args:
11440 
  """
11441 
  Attributes:
11442 
   - bannerName
11443 
   - mapLink
11444 
   - coordinates
11445 
  """
11446 
 
11447 
  thrift_spec = (
11448 
    None, # 0
11449 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11450 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11451 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11452 
  )
11453 
 
11454 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11455 
    self.bannerName = bannerName
11456 
    self.mapLink = mapLink
11457 
    self.coordinates = coordinates
11458 
 
11459 
  def read(self, iprot):
11460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11462 
      return
11463 
    iprot.readStructBegin()
11464 
    while True:
11465 
      (fname, ftype, fid) = iprot.readFieldBegin()
11466 
      if ftype == TType.STOP:
11467 
        break
11468 
      if fid == 1:
11469 
        if ftype == TType.STRING:
11470 
          self.bannerName = iprot.readString();
11471 
        else:
11472 
          iprot.skip(ftype)
11473 
      elif fid == 2:
11474 
        if ftype == TType.STRING:
11475 
          self.mapLink = iprot.readString();
11476 
        else:
11477 
          iprot.skip(ftype)
11478 
      elif fid == 3:
11479 
        if ftype == TType.STRING:
11480 
          self.coordinates = iprot.readString();
11481 
        else:
11482 
          iprot.skip(ftype)
11483 
      else:
11484 
        iprot.skip(ftype)
11485 
      iprot.readFieldEnd()
11486 
    iprot.readStructEnd()
11487 
 
11488 
  def write(self, oprot):
11489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11491 
      return
11492 
    oprot.writeStructBegin('addBannerMap_args')
11493 
    if self.bannerName is not None:
11494 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11495 
      oprot.writeString(self.bannerName)
11496 
      oprot.writeFieldEnd()
11497 
    if self.mapLink is not None:
11498 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11499 
      oprot.writeString(self.mapLink)
11500 
      oprot.writeFieldEnd()
11501 
    if self.coordinates is not None:
11502 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11503 
      oprot.writeString(self.coordinates)
11504 
      oprot.writeFieldEnd()
11505 
    oprot.writeFieldStop()
11506 
    oprot.writeStructEnd()
11507 
 
11508 
  def validate(self):
11509 
    return
11510 
 
11511 
 
11512 
  def __repr__(self):
11513 
    L = ['%s=%r' % (key, value)
11514 
      for key, value in self.__dict__.iteritems()]
11515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11516 
 
11517 
  def __eq__(self, other):
11518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11519 
 
11520 
  def __ne__(self, other):
11521 
    return not (self == other)
11522 
 
11523 
class addBannerMap_result:
11524 
  """
11525 
  Attributes:
11526 
   - success
11527 
  """
11528 
 
11529 
  thrift_spec = (
11530 
    (0, TType.BOOL, 'success', None, None, ), # 0
11531 
  )
11532 
 
11533 
  def __init__(self, success=None,):
11534 
    self.success = success
11535 
 
11536 
  def read(self, iprot):
11537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11539 
      return
11540 
    iprot.readStructBegin()
11541 
    while True:
11542 
      (fname, ftype, fid) = iprot.readFieldBegin()
11543 
      if ftype == TType.STOP:
11544 
        break
11545 
      if fid == 0:
11546 
        if ftype == TType.BOOL:
11547 
          self.success = iprot.readBool();
11548 
        else:
11549 
          iprot.skip(ftype)
11550 
      else:
11551 
        iprot.skip(ftype)
11552 
      iprot.readFieldEnd()
11553 
    iprot.readStructEnd()
11554 
 
11555 
  def write(self, oprot):
11556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11558 
      return
11559 
    oprot.writeStructBegin('addBannerMap_result')
11560 
    if self.success is not None:
11561 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11562 
      oprot.writeBool(self.success)
11563 
      oprot.writeFieldEnd()
11564 
    oprot.writeFieldStop()
11565 
    oprot.writeStructEnd()
11566 
 
11567 
  def validate(self):
11568 
    return
11569 
 
11570 
 
11571 
  def __repr__(self):
11572 
    L = ['%s=%r' % (key, value)
11573 
      for key, value in self.__dict__.iteritems()]
11574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11575 
 
11576 
  def __eq__(self, other):
11577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11578 
 
11579 
  def __ne__(self, other):
11580 
    return not (self == other)
11581 
 
11582 
class deleteBannerMap_args:
11583 
  """
11584 
  Attributes:
11585 
   - bannerName
11586 
  """
11587 
 
11588 
  thrift_spec = (
11589 
    None, # 0
11590 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11591 
  )
11592 
 
11593 
  def __init__(self, bannerName=None,):
11594 
    self.bannerName = bannerName
11595 
 
11596 
  def read(self, iprot):
11597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11599 
      return
11600 
    iprot.readStructBegin()
11601 
    while True:
11602 
      (fname, ftype, fid) = iprot.readFieldBegin()
11603 
      if ftype == TType.STOP:
11604 
        break
11605 
      if fid == 1:
11606 
        if ftype == TType.STRING:
11607 
          self.bannerName = iprot.readString();
11608 
        else:
11609 
          iprot.skip(ftype)
11610 
      else:
11611 
        iprot.skip(ftype)
11612 
      iprot.readFieldEnd()
11613 
    iprot.readStructEnd()
11614 
 
11615 
  def write(self, oprot):
11616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11618 
      return
11619 
    oprot.writeStructBegin('deleteBannerMap_args')
11620 
    if self.bannerName is not None:
11621 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11622 
      oprot.writeString(self.bannerName)
11623 
      oprot.writeFieldEnd()
11624 
    oprot.writeFieldStop()
11625 
    oprot.writeStructEnd()
11626 
 
11627 
  def validate(self):
11628 
    return
11629 
 
11630 
 
11631 
  def __repr__(self):
11632 
    L = ['%s=%r' % (key, value)
11633 
      for key, value in self.__dict__.iteritems()]
11634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11635 
 
11636 
  def __eq__(self, other):
11637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11638 
 
11639 
  def __ne__(self, other):
11640 
    return not (self == other)
11641 
 
11642 
class deleteBannerMap_result:
11643 
  """
11644 
  Attributes:
11645 
   - success
11646 
  """
11647 
 
11648 
  thrift_spec = (
11649 
    (0, TType.BOOL, 'success', None, None, ), # 0
11650 
  )
11651 
 
11652 
  def __init__(self, success=None,):
11653 
    self.success = success
11654 
 
11655 
  def read(self, iprot):
11656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11658 
      return
11659 
    iprot.readStructBegin()
11660 
    while True:
11661 
      (fname, ftype, fid) = iprot.readFieldBegin()
11662 
      if ftype == TType.STOP:
11663 
        break
11664 
      if fid == 0:
11665 
        if ftype == TType.BOOL:
11666 
          self.success = iprot.readBool();
11667 
        else:
11668 
          iprot.skip(ftype)
11669 
      else:
11670 
        iprot.skip(ftype)
11671 
      iprot.readFieldEnd()
11672 
    iprot.readStructEnd()
11673 
 
11674 
  def write(self, oprot):
11675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11677 
      return
11678 
    oprot.writeStructBegin('deleteBannerMap_result')
11679 
    if self.success is not None:
11680 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11681 
      oprot.writeBool(self.success)
11682 
      oprot.writeFieldEnd()
11683 
    oprot.writeFieldStop()
11684 
    oprot.writeStructEnd()
11685 
 
11686 
  def validate(self):
11687 
    return
11688 
 
11689 
 
11690 
  def __repr__(self):
11691 
    L = ['%s=%r' % (key, value)
11692 
      for key, value in self.__dict__.iteritems()]
11693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11694 
 
11695 
  def __eq__(self, other):
11696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11697 
 
11698 
  def __ne__(self, other):
11699 
    return not (self == other)
11700 
 
11701 
class getBannerMapDetails_args:
11702 
  """
11703 
  Attributes:
11704 
   - bannerName
11705 
  """
11706 
 
11707 
  thrift_spec = (
11708 
    None, # 0
11709 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11710 
  )
11711 
 
11712 
  def __init__(self, bannerName=None,):
11713 
    self.bannerName = bannerName
11714 
 
11715 
  def read(self, iprot):
11716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11718 
      return
11719 
    iprot.readStructBegin()
11720 
    while True:
11721 
      (fname, ftype, fid) = iprot.readFieldBegin()
11722 
      if ftype == TType.STOP:
11723 
        break
11724 
      if fid == 1:
11725 
        if ftype == TType.STRING:
11726 
          self.bannerName = iprot.readString();
11727 
        else:
11728 
          iprot.skip(ftype)
11729 
      else:
11730 
        iprot.skip(ftype)
11731 
      iprot.readFieldEnd()
11732 
    iprot.readStructEnd()
11733 
 
11734 
  def write(self, oprot):
11735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11737 
      return
11738 
    oprot.writeStructBegin('getBannerMapDetails_args')
11739 
    if self.bannerName is not None:
11740 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11741 
      oprot.writeString(self.bannerName)
11742 
      oprot.writeFieldEnd()
11743 
    oprot.writeFieldStop()
11744 
    oprot.writeStructEnd()
11745 
 
11746 
  def validate(self):
11747 
    return
11748 
 
11749 
 
11750 
  def __repr__(self):
11751 
    L = ['%s=%r' % (key, value)
11752 
      for key, value in self.__dict__.iteritems()]
11753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11754 
 
11755 
  def __eq__(self, other):
11756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11757 
 
11758 
  def __ne__(self, other):
11759 
    return not (self == other)
11760 
 
11761 
class getBannerMapDetails_result:
11762 
  """
11763 
  Attributes:
11764 
   - success
11765 
  """
11766 
 
11767 
  thrift_spec = (
11768 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11769 
  )
11770 
 
11771 
  def __init__(self, success=None,):
11772 
    self.success = success
11773 
 
11774 
  def read(self, iprot):
11775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11777 
      return
11778 
    iprot.readStructBegin()
11779 
    while True:
11780 
      (fname, ftype, fid) = iprot.readFieldBegin()
11781 
      if ftype == TType.STOP:
11782 
        break
11783 
      if fid == 0:
11784 
        if ftype == TType.LIST:
11785 
          self.success = []
7438 amit.gupta 11786 
          (_etype198, _size195) = iprot.readListBegin()
11787 
          for _i199 in xrange(_size195):
11788 
            _elem200 = BannerMap()
11789 
            _elem200.read(iprot)
11790 
            self.success.append(_elem200)
6849 kshitij.so 11791 
          iprot.readListEnd()
11792 
        else:
11793 
          iprot.skip(ftype)
11794 
      else:
11795 
        iprot.skip(ftype)
11796 
      iprot.readFieldEnd()
11797 
    iprot.readStructEnd()
11798 
 
11799 
  def write(self, oprot):
11800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11802 
      return
11803 
    oprot.writeStructBegin('getBannerMapDetails_result')
11804 
    if self.success is not None:
11805 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11806 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11807 
      for iter201 in self.success:
11808 
        iter201.write(oprot)
6849 kshitij.so 11809 
      oprot.writeListEnd()
11810 
      oprot.writeFieldEnd()
11811 
    oprot.writeFieldStop()
11812 
    oprot.writeStructEnd()
11813 
 
11814 
  def validate(self):
11815 
    return
11816 
 
11817 
 
11818 
  def __repr__(self):
11819 
    L = ['%s=%r' % (key, value)
11820 
      for key, value in self.__dict__.iteritems()]
11821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11822 
 
11823 
  def __eq__(self, other):
11824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11825 
 
11826 
  def __ne__(self, other):
11827 
    return not (self == other)
11828 
 
5944 mandeep.dh 11829 
class deleteSimilarItem_args:
11830 
  """
11831 
  Attributes:
11832 
   - itemId
11833 
   - catalogItemId
11834 
  """
11835 
 
11836 
  thrift_spec = (
11837 
    None, # 0
11838 
    (1, TType.I64, 'itemId', None, None, ), # 1
11839 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11840 
  )
11841 
 
11842 
  def __init__(self, itemId=None, catalogItemId=None,):
11843 
    self.itemId = itemId
11844 
    self.catalogItemId = catalogItemId
11845 
 
11846 
  def read(self, iprot):
11847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11849 
      return
11850 
    iprot.readStructBegin()
11851 
    while True:
11852 
      (fname, ftype, fid) = iprot.readFieldBegin()
11853 
      if ftype == TType.STOP:
11854 
        break
11855 
      if fid == 1:
11856 
        if ftype == TType.I64:
11857 
          self.itemId = iprot.readI64();
11858 
        else:
11859 
          iprot.skip(ftype)
11860 
      elif fid == 2:
11861 
        if ftype == TType.I64:
11862 
          self.catalogItemId = iprot.readI64();
11863 
        else:
11864 
          iprot.skip(ftype)
11865 
      else:
11866 
        iprot.skip(ftype)
11867 
      iprot.readFieldEnd()
11868 
    iprot.readStructEnd()
11869 
 
11870 
  def write(self, oprot):
11871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11873 
      return
11874 
    oprot.writeStructBegin('deleteSimilarItem_args')
11875 
    if self.itemId is not None:
11876 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11877 
      oprot.writeI64(self.itemId)
11878 
      oprot.writeFieldEnd()
11879 
    if self.catalogItemId is not None:
11880 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11881 
      oprot.writeI64(self.catalogItemId)
11882 
      oprot.writeFieldEnd()
11883 
    oprot.writeFieldStop()
11884 
    oprot.writeStructEnd()
11885 
 
11886 
  def validate(self):
11887 
    return
11888 
 
11889 
 
11890 
  def __repr__(self):
11891 
    L = ['%s=%r' % (key, value)
11892 
      for key, value in self.__dict__.iteritems()]
11893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11894 
 
11895 
  def __eq__(self, other):
11896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11897 
 
11898 
  def __ne__(self, other):
11899 
    return not (self == other)
11900 
 
11901 
class deleteSimilarItem_result:
11902 
  """
11903 
  Attributes:
11904 
   - success
11905 
   - cex
11906 
  """
11907 
 
11908 
  thrift_spec = (
11909 
    (0, TType.BOOL, 'success', None, None, ), # 0
11910 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11911 
  )
11912 
 
11913 
  def __init__(self, success=None, cex=None,):
11914 
    self.success = success
11915 
    self.cex = cex
11916 
 
11917 
  def read(self, iprot):
11918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11920 
      return
11921 
    iprot.readStructBegin()
11922 
    while True:
11923 
      (fname, ftype, fid) = iprot.readFieldBegin()
11924 
      if ftype == TType.STOP:
11925 
        break
11926 
      if fid == 0:
11927 
        if ftype == TType.BOOL:
11928 
          self.success = iprot.readBool();
11929 
        else:
11930 
          iprot.skip(ftype)
11931 
      elif fid == 1:
11932 
        if ftype == TType.STRUCT:
11933 
          self.cex = CatalogServiceException()
11934 
          self.cex.read(iprot)
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      else:
11938 
        iprot.skip(ftype)
11939 
      iprot.readFieldEnd()
11940 
    iprot.readStructEnd()
11941 
 
11942 
  def write(self, oprot):
11943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11945 
      return
11946 
    oprot.writeStructBegin('deleteSimilarItem_result')
11947 
    if self.success is not None:
11948 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11949 
      oprot.writeBool(self.success)
11950 
      oprot.writeFieldEnd()
11951 
    if self.cex is not None:
11952 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11953 
      self.cex.write(oprot)
11954 
      oprot.writeFieldEnd()
11955 
    oprot.writeFieldStop()
11956 
    oprot.writeStructEnd()
11957 
 
11958 
  def validate(self):
11959 
    return
11960 
 
11961 
 
11962 
  def __repr__(self):
11963 
    L = ['%s=%r' % (key, value)
11964 
      for key, value in self.__dict__.iteritems()]
11965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11966 
 
11967 
  def __eq__(self, other):
11968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11969 
 
11970 
  def __ne__(self, other):
11971 
    return not (self == other)
11972 
 
11973 
class checkSimilarItem_args:
11974 
  """
11975 
  Attributes:
11976 
   - brand
11977 
   - modelNumber
11978 
   - modelName
11979 
   - color
11980 
  """
11981 
 
11982 
  thrift_spec = (
11983 
    None, # 0
11984 
    (1, TType.STRING, 'brand', None, None, ), # 1
11985 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11986 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11987 
    (4, TType.STRING, 'color', None, None, ), # 4
11988 
  )
11989 
 
11990 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11991 
    self.brand = brand
11992 
    self.modelNumber = modelNumber
11993 
    self.modelName = modelName
11994 
    self.color = color
11995 
 
11996 
  def read(self, iprot):
11997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11999 
      return
12000 
    iprot.readStructBegin()
12001 
    while True:
12002 
      (fname, ftype, fid) = iprot.readFieldBegin()
12003 
      if ftype == TType.STOP:
12004 
        break
12005 
      if fid == 1:
12006 
        if ftype == TType.STRING:
12007 
          self.brand = iprot.readString();
12008 
        else:
12009 
          iprot.skip(ftype)
12010 
      elif fid == 2:
12011 
        if ftype == TType.STRING:
12012 
          self.modelNumber = iprot.readString();
12013 
        else:
12014 
          iprot.skip(ftype)
12015 
      elif fid == 3:
12016 
        if ftype == TType.STRING:
12017 
          self.modelName = iprot.readString();
12018 
        else:
12019 
          iprot.skip(ftype)
12020 
      elif fid == 4:
12021 
        if ftype == TType.STRING:
12022 
          self.color = iprot.readString();
12023 
        else:
12024 
          iprot.skip(ftype)
12025 
      else:
12026 
        iprot.skip(ftype)
12027 
      iprot.readFieldEnd()
12028 
    iprot.readStructEnd()
12029 
 
12030 
  def write(self, oprot):
12031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12033 
      return
12034 
    oprot.writeStructBegin('checkSimilarItem_args')
12035 
    if self.brand is not None:
12036 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
12037 
      oprot.writeString(self.brand)
12038 
      oprot.writeFieldEnd()
12039 
    if self.modelNumber is not None:
12040 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
12041 
      oprot.writeString(self.modelNumber)
12042 
      oprot.writeFieldEnd()
12043 
    if self.modelName is not None:
12044 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12045 
      oprot.writeString(self.modelName)
12046 
      oprot.writeFieldEnd()
12047 
    if self.color is not None:
12048 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12049 
      oprot.writeString(self.color)
12050 
      oprot.writeFieldEnd()
12051 
    oprot.writeFieldStop()
12052 
    oprot.writeStructEnd()
12053 
 
12054 
  def validate(self):
12055 
    return
12056 
 
12057 
 
12058 
  def __repr__(self):
12059 
    L = ['%s=%r' % (key, value)
12060 
      for key, value in self.__dict__.iteritems()]
12061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12062 
 
12063 
  def __eq__(self, other):
12064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12065 
 
12066 
  def __ne__(self, other):
12067 
    return not (self == other)
12068 
 
12069 
class checkSimilarItem_result:
12070 
  """
12071 
  Attributes:
12072 
   - success
12073 
  """
12074 
 
12075 
  thrift_spec = (
12076 
    (0, TType.I64, 'success', None, None, ), # 0
12077 
  )
12078 
 
12079 
  def __init__(self, success=None,):
12080 
    self.success = success
12081 
 
12082 
  def read(self, iprot):
12083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12085 
      return
12086 
    iprot.readStructBegin()
12087 
    while True:
12088 
      (fname, ftype, fid) = iprot.readFieldBegin()
12089 
      if ftype == TType.STOP:
12090 
        break
12091 
      if fid == 0:
12092 
        if ftype == TType.I64:
12093 
          self.success = iprot.readI64();
12094 
        else:
12095 
          iprot.skip(ftype)
12096 
      else:
12097 
        iprot.skip(ftype)
12098 
      iprot.readFieldEnd()
12099 
    iprot.readStructEnd()
12100 
 
12101 
  def write(self, oprot):
12102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12104 
      return
12105 
    oprot.writeStructBegin('checkSimilarItem_result')
12106 
    if self.success is not None:
12107 
      oprot.writeFieldBegin('success', TType.I64, 0)
12108 
      oprot.writeI64(self.success)
12109 
      oprot.writeFieldEnd()
12110 
    oprot.writeFieldStop()
12111 
    oprot.writeStructEnd()
12112 
 
12113 
  def validate(self):
12114 
    return
12115 
 
12116 
 
12117 
  def __repr__(self):
12118 
    L = ['%s=%r' % (key, value)
12119 
      for key, value in self.__dict__.iteritems()]
12120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12121 
 
12122 
  def __eq__(self, other):
12123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12124 
 
12125 
  def __ne__(self, other):
12126 
    return not (self == other)
12127 
 
12128 
class validateRiskyStatus_args:
12129 
  """
12130 
  Attributes:
12131 
   - itemId
12132 
  """
12133 
 
12134 
  thrift_spec = (
12135 
    None, # 0
12136 
    (1, TType.I64, 'itemId', None, None, ), # 1
12137 
  )
12138 
 
12139 
  def __init__(self, itemId=None,):
12140 
    self.itemId = itemId
12141 
 
12142 
  def read(self, iprot):
12143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12145 
      return
12146 
    iprot.readStructBegin()
12147 
    while True:
12148 
      (fname, ftype, fid) = iprot.readFieldBegin()
12149 
      if ftype == TType.STOP:
12150 
        break
12151 
      if fid == 1:
12152 
        if ftype == TType.I64:
12153 
          self.itemId = iprot.readI64();
12154 
        else:
12155 
          iprot.skip(ftype)
12156 
      else:
12157 
        iprot.skip(ftype)
12158 
      iprot.readFieldEnd()
12159 
    iprot.readStructEnd()
12160 
 
12161 
  def write(self, oprot):
12162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12164 
      return
12165 
    oprot.writeStructBegin('validateRiskyStatus_args')
12166 
    if self.itemId is not None:
12167 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12168 
      oprot.writeI64(self.itemId)
12169 
      oprot.writeFieldEnd()
12170 
    oprot.writeFieldStop()
12171 
    oprot.writeStructEnd()
12172 
 
12173 
  def validate(self):
12174 
    return
12175 
 
12176 
 
12177 
  def __repr__(self):
12178 
    L = ['%s=%r' % (key, value)
12179 
      for key, value in self.__dict__.iteritems()]
12180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12181 
 
12182 
  def __eq__(self, other):
12183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12184 
 
12185 
  def __ne__(self, other):
12186 
    return not (self == other)
12187 
 
12188 
class validateRiskyStatus_result:
12189 
 
12190 
  thrift_spec = (
12191 
  )
12192 
 
12193 
  def read(self, iprot):
12194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12196 
      return
12197 
    iprot.readStructBegin()
12198 
    while True:
12199 
      (fname, ftype, fid) = iprot.readFieldBegin()
12200 
      if ftype == TType.STOP:
12201 
        break
12202 
      else:
12203 
        iprot.skip(ftype)
12204 
      iprot.readFieldEnd()
12205 
    iprot.readStructEnd()
12206 
 
12207 
  def write(self, oprot):
12208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12210 
      return
12211 
    oprot.writeStructBegin('validateRiskyStatus_result')
12212 
    oprot.writeFieldStop()
12213 
    oprot.writeStructEnd()
12214 
 
12215 
  def validate(self):
12216 
    return
12217 
 
12218 
 
12219 
  def __repr__(self):
12220 
    L = ['%s=%r' % (key, value)
12221 
      for key, value in self.__dict__.iteritems()]
12222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12223 
 
12224 
  def __eq__(self, other):
12225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12226 
 
12227 
  def __ne__(self, other):
12228 
    return not (self == other)
12229 
 
12230 
class changeItemRiskyFlag_args:
12231 
  """
12232 
  Attributes:
12233 
   - itemId
12234 
   - risky
12235 
  """
12236 
 
12237 
  thrift_spec = (
12238 
    None, # 0
12239 
    (1, TType.I64, 'itemId', None, None, ), # 1
12240 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12241 
  )
12242 
 
12243 
  def __init__(self, itemId=None, risky=None,):
12244 
    self.itemId = itemId
12245 
    self.risky = risky
12246 
 
12247 
  def read(self, iprot):
12248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12250 
      return
12251 
    iprot.readStructBegin()
12252 
    while True:
12253 
      (fname, ftype, fid) = iprot.readFieldBegin()
12254 
      if ftype == TType.STOP:
12255 
        break
12256 
      if fid == 1:
12257 
        if ftype == TType.I64:
12258 
          self.itemId = iprot.readI64();
12259 
        else:
12260 
          iprot.skip(ftype)
12261 
      elif fid == 2:
12262 
        if ftype == TType.BOOL:
12263 
          self.risky = iprot.readBool();
12264 
        else:
12265 
          iprot.skip(ftype)
12266 
      else:
12267 
        iprot.skip(ftype)
12268 
      iprot.readFieldEnd()
12269 
    iprot.readStructEnd()
12270 
 
12271 
  def write(self, oprot):
12272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12274 
      return
12275 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12276 
    if self.itemId is not None:
12277 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12278 
      oprot.writeI64(self.itemId)
12279 
      oprot.writeFieldEnd()
12280 
    if self.risky is not None:
12281 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12282 
      oprot.writeBool(self.risky)
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 changeItemRiskyFlag_result:
12303 
 
12304 
  thrift_spec = (
12305 
  )
12306 
 
12307 
  def read(self, iprot):
12308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12310 
      return
12311 
    iprot.readStructBegin()
12312 
    while True:
12313 
      (fname, ftype, fid) = iprot.readFieldBegin()
12314 
      if ftype == TType.STOP:
12315 
        break
12316 
      else:
12317 
        iprot.skip(ftype)
12318 
      iprot.readFieldEnd()
12319 
    iprot.readStructEnd()
12320 
 
12321 
  def write(self, oprot):
12322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12324 
      return
12325 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12326 
    oprot.writeFieldStop()
12327 
    oprot.writeStructEnd()
12328 
 
12329 
  def validate(self):
12330 
    return
12331 
 
12332 
 
12333 
  def __repr__(self):
12334 
    L = ['%s=%r' % (key, value)
12335 
      for key, value in self.__dict__.iteritems()]
12336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12337 
 
12338 
  def __eq__(self, other):
12339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12340 
 
12341 
  def __ne__(self, other):
12342 
    return not (self == other)
12343 
 
12344 
class getItemsByRiskyFlag_args:
12345 
 
12346 
  thrift_spec = (
12347 
  )
12348 
 
12349 
  def read(self, iprot):
12350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12352 
      return
12353 
    iprot.readStructBegin()
12354 
    while True:
12355 
      (fname, ftype, fid) = iprot.readFieldBegin()
12356 
      if ftype == TType.STOP:
12357 
        break
12358 
      else:
12359 
        iprot.skip(ftype)
12360 
      iprot.readFieldEnd()
12361 
    iprot.readStructEnd()
12362 
 
12363 
  def write(self, oprot):
12364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12366 
      return
12367 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12368 
    oprot.writeFieldStop()
12369 
    oprot.writeStructEnd()
12370 
 
12371 
  def validate(self):
12372 
    return
12373 
 
12374 
 
12375 
  def __repr__(self):
12376 
    L = ['%s=%r' % (key, value)
12377 
      for key, value in self.__dict__.iteritems()]
12378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12379 
 
12380 
  def __eq__(self, other):
12381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12382 
 
12383 
  def __ne__(self, other):
12384 
    return not (self == other)
12385 
 
12386 
class getItemsByRiskyFlag_result:
12387 
  """
12388 
  Attributes:
12389 
   - success
12390 
  """
12391 
 
12392 
  thrift_spec = (
12393 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12394 
  )
12395 
 
12396 
  def __init__(self, success=None,):
12397 
    self.success = success
12398 
 
12399 
  def read(self, iprot):
12400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12402 
      return
12403 
    iprot.readStructBegin()
12404 
    while True:
12405 
      (fname, ftype, fid) = iprot.readFieldBegin()
12406 
      if ftype == TType.STOP:
12407 
        break
12408 
      if fid == 0:
12409 
        if ftype == TType.LIST:
12410 
          self.success = []
7438 amit.gupta 12411 
          (_etype205, _size202) = iprot.readListBegin()
12412 
          for _i206 in xrange(_size202):
12413 
            _elem207 = Item()
12414 
            _elem207.read(iprot)
12415 
            self.success.append(_elem207)
5944 mandeep.dh 12416 
          iprot.readListEnd()
12417 
        else:
12418 
          iprot.skip(ftype)
12419 
      else:
12420 
        iprot.skip(ftype)
12421 
      iprot.readFieldEnd()
12422 
    iprot.readStructEnd()
12423 
 
12424 
  def write(self, oprot):
12425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12427 
      return
12428 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12429 
    if self.success is not None:
12430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12432 
      for iter208 in self.success:
12433 
        iter208.write(oprot)
5944 mandeep.dh 12434 
      oprot.writeListEnd()
12435 
      oprot.writeFieldEnd()
12436 
    oprot.writeFieldStop()
12437 
    oprot.writeStructEnd()
12438 
 
12439 
  def validate(self):
12440 
    return
12441 
 
12442 
 
12443 
  def __repr__(self):
12444 
    L = ['%s=%r' % (key, value)
12445 
      for key, value in self.__dict__.iteritems()]
12446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12447 
 
12448 
  def __eq__(self, other):
12449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12450 
 
12451 
  def __ne__(self, other):
12452 
    return not (self == other)
12453 
 
12454 
class getItemsForMasterSheet_args:
12455 
  """
12456 
  Attributes:
12457 
   - category
12458 
   - brand
12459 
  """
12460 
 
12461 
  thrift_spec = (
12462 
    None, # 0
12463 
    (1, TType.STRING, 'category', None, None, ), # 1
12464 
    (2, TType.STRING, 'brand', None, None, ), # 2
12465 
  )
12466 
 
12467 
  def __init__(self, category=None, brand=None,):
12468 
    self.category = category
12469 
    self.brand = brand
12470 
 
12471 
  def read(self, iprot):
12472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12474 
      return
12475 
    iprot.readStructBegin()
12476 
    while True:
12477 
      (fname, ftype, fid) = iprot.readFieldBegin()
12478 
      if ftype == TType.STOP:
12479 
        break
12480 
      if fid == 1:
12481 
        if ftype == TType.STRING:
12482 
          self.category = iprot.readString();
12483 
        else:
12484 
          iprot.skip(ftype)
12485 
      elif fid == 2:
12486 
        if ftype == TType.STRING:
12487 
          self.brand = iprot.readString();
12488 
        else:
12489 
          iprot.skip(ftype)
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('getItemsForMasterSheet_args')
12500 
    if self.category is not None:
12501 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12502 
      oprot.writeString(self.category)
12503 
      oprot.writeFieldEnd()
12504 
    if self.brand is not None:
12505 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12506 
      oprot.writeString(self.brand)
12507 
      oprot.writeFieldEnd()
12508 
    oprot.writeFieldStop()
12509 
    oprot.writeStructEnd()
12510 
 
12511 
  def validate(self):
12512 
    return
12513 
 
12514 
 
12515 
  def __repr__(self):
12516 
    L = ['%s=%r' % (key, value)
12517 
      for key, value in self.__dict__.iteritems()]
12518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12519 
 
12520 
  def __eq__(self, other):
12521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12522 
 
12523 
  def __ne__(self, other):
12524 
    return not (self == other)
12525 
 
12526 
class getItemsForMasterSheet_result:
12527 
  """
12528 
  Attributes:
12529 
   - success
12530 
  """
12531 
 
12532 
  thrift_spec = (
12533 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12534 
  )
12535 
 
12536 
  def __init__(self, success=None,):
12537 
    self.success = success
12538 
 
12539 
  def read(self, iprot):
12540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12542 
      return
12543 
    iprot.readStructBegin()
12544 
    while True:
12545 
      (fname, ftype, fid) = iprot.readFieldBegin()
12546 
      if ftype == TType.STOP:
12547 
        break
12548 
      if fid == 0:
12549 
        if ftype == TType.LIST:
12550 
          self.success = []
7438 amit.gupta 12551 
          (_etype212, _size209) = iprot.readListBegin()
12552 
          for _i213 in xrange(_size209):
12553 
            _elem214 = Item()
12554 
            _elem214.read(iprot)
12555 
            self.success.append(_elem214)
5944 mandeep.dh 12556 
          iprot.readListEnd()
12557 
        else:
12558 
          iprot.skip(ftype)
12559 
      else:
12560 
        iprot.skip(ftype)
12561 
      iprot.readFieldEnd()
12562 
    iprot.readStructEnd()
12563 
 
12564 
  def write(self, oprot):
12565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12567 
      return
12568 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12569 
    if self.success is not None:
12570 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12571 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12572 
      for iter215 in self.success:
12573 
        iter215.write(oprot)
5944 mandeep.dh 12574 
      oprot.writeListEnd()
12575 
      oprot.writeFieldEnd()
12576 
    oprot.writeFieldStop()
12577 
    oprot.writeStructEnd()
12578 
 
12579 
  def validate(self):
12580 
    return
12581 
 
12582 
 
12583 
  def __repr__(self):
12584 
    L = ['%s=%r' % (key, value)
12585 
      for key, value in self.__dict__.iteritems()]
12586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12587 
 
12588 
  def __eq__(self, other):
12589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12590 
 
12591 
  def __ne__(self, other):
12592 
    return not (self == other)
12593 
 
12594 
class getSimilarItemsCatalogIds_args:
12595 
  """
12596 
  Attributes:
12597 
   - beginIndex
12598 
   - totalItems
12599 
   - itemId
12600 
  """
12601 
 
12602 
  thrift_spec = (
12603 
    None, # 0
12604 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12605 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12606 
    (3, TType.I64, 'itemId', None, None, ), # 3
12607 
  )
12608 
 
12609 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12610 
    self.beginIndex = beginIndex
12611 
    self.totalItems = totalItems
12612 
    self.itemId = itemId
12613 
 
12614 
  def read(self, iprot):
12615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12617 
      return
12618 
    iprot.readStructBegin()
12619 
    while True:
12620 
      (fname, ftype, fid) = iprot.readFieldBegin()
12621 
      if ftype == TType.STOP:
12622 
        break
12623 
      if fid == 1:
12624 
        if ftype == TType.I64:
12625 
          self.beginIndex = iprot.readI64();
12626 
        else:
12627 
          iprot.skip(ftype)
12628 
      elif fid == 2:
12629 
        if ftype == TType.I64:
12630 
          self.totalItems = iprot.readI64();
12631 
        else:
12632 
          iprot.skip(ftype)
12633 
      elif fid == 3:
12634 
        if ftype == TType.I64:
12635 
          self.itemId = iprot.readI64();
12636 
        else:
12637 
          iprot.skip(ftype)
12638 
      else:
12639 
        iprot.skip(ftype)
12640 
      iprot.readFieldEnd()
12641 
    iprot.readStructEnd()
12642 
 
12643 
  def write(self, oprot):
12644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12646 
      return
12647 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12648 
    if self.beginIndex is not None:
12649 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12650 
      oprot.writeI64(self.beginIndex)
12651 
      oprot.writeFieldEnd()
12652 
    if self.totalItems is not None:
12653 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12654 
      oprot.writeI64(self.totalItems)
12655 
      oprot.writeFieldEnd()
12656 
    if self.itemId is not None:
12657 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12658 
      oprot.writeI64(self.itemId)
12659 
      oprot.writeFieldEnd()
12660 
    oprot.writeFieldStop()
12661 
    oprot.writeStructEnd()
12662 
 
12663 
  def validate(self):
12664 
    return
12665 
 
12666 
 
12667 
  def __repr__(self):
12668 
    L = ['%s=%r' % (key, value)
12669 
      for key, value in self.__dict__.iteritems()]
12670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12671 
 
12672 
  def __eq__(self, other):
12673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12674 
 
12675 
  def __ne__(self, other):
12676 
    return not (self == other)
12677 
 
12678 
class getSimilarItemsCatalogIds_result:
12679 
  """
12680 
  Attributes:
12681 
   - success
12682 
  """
12683 
 
12684 
  thrift_spec = (
12685 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12686 
  )
12687 
 
12688 
  def __init__(self, success=None,):
12689 
    self.success = success
12690 
 
12691 
  def read(self, iprot):
12692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12694 
      return
12695 
    iprot.readStructBegin()
12696 
    while True:
12697 
      (fname, ftype, fid) = iprot.readFieldBegin()
12698 
      if ftype == TType.STOP:
12699 
        break
12700 
      if fid == 0:
12701 
        if ftype == TType.LIST:
12702 
          self.success = []
7438 amit.gupta 12703 
          (_etype219, _size216) = iprot.readListBegin()
12704 
          for _i220 in xrange(_size216):
12705 
            _elem221 = iprot.readI64();
12706 
            self.success.append(_elem221)
5944 mandeep.dh 12707 
          iprot.readListEnd()
12708 
        else:
12709 
          iprot.skip(ftype)
12710 
      else:
12711 
        iprot.skip(ftype)
12712 
      iprot.readFieldEnd()
12713 
    iprot.readStructEnd()
12714 
 
12715 
  def write(self, oprot):
12716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12718 
      return
12719 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12720 
    if self.success is not None:
12721 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12722 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12723 
      for iter222 in self.success:
12724 
        oprot.writeI64(iter222)
5944 mandeep.dh 12725 
      oprot.writeListEnd()
12726 
      oprot.writeFieldEnd()
12727 
    oprot.writeFieldStop()
12728 
    oprot.writeStructEnd()
12729 
 
12730 
  def validate(self):
12731 
    return
12732 
 
12733 
 
12734 
  def __repr__(self):
12735 
    L = ['%s=%r' % (key, value)
12736 
      for key, value in self.__dict__.iteritems()]
12737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12738 
 
12739 
  def __eq__(self, other):
12740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12741 
 
12742 
  def __ne__(self, other):
12743 
    return not (self == other)
12744 
 
12745 
class addProductNotification_args:
12746 
  """
12747 
  Attributes:
12748 
   - itemId
12749 
   - email
12750 
  """
12751 
 
12752 
  thrift_spec = None
12753 
  def __init__(self, itemId=None, email=None,):
12754 
    self.itemId = itemId
12755 
    self.email = email
12756 
 
12757 
  def read(self, iprot):
12758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12760 
      return
12761 
    iprot.readStructBegin()
12762 
    while True:
12763 
      (fname, ftype, fid) = iprot.readFieldBegin()
12764 
      if ftype == TType.STOP:
12765 
        break
12766 
      if fid == -1:
12767 
        if ftype == TType.I64:
12768 
          self.itemId = iprot.readI64();
12769 
        else:
12770 
          iprot.skip(ftype)
12771 
      elif fid == -2:
12772 
        if ftype == TType.STRING:
12773 
          self.email = iprot.readString();
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      else:
12777 
        iprot.skip(ftype)
12778 
      iprot.readFieldEnd()
12779 
    iprot.readStructEnd()
12780 
 
12781 
  def write(self, oprot):
12782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12784 
      return
12785 
    oprot.writeStructBegin('addProductNotification_args')
12786 
    if self.email is not None:
12787 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12788 
      oprot.writeString(self.email)
12789 
      oprot.writeFieldEnd()
12790 
    if self.itemId is not None:
12791 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12792 
      oprot.writeI64(self.itemId)
12793 
      oprot.writeFieldEnd()
12794 
    oprot.writeFieldStop()
12795 
    oprot.writeStructEnd()
12796 
 
12797 
  def validate(self):
12798 
    return
12799 
 
12800 
 
12801 
  def __repr__(self):
12802 
    L = ['%s=%r' % (key, value)
12803 
      for key, value in self.__dict__.iteritems()]
12804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12805 
 
12806 
  def __eq__(self, other):
12807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12808 
 
12809 
  def __ne__(self, other):
12810 
    return not (self == other)
12811 
 
12812 
class addProductNotification_result:
12813 
  """
12814 
  Attributes:
12815 
   - success
12816 
  """
12817 
 
12818 
  thrift_spec = (
12819 
    (0, TType.BOOL, 'success', None, None, ), # 0
12820 
  )
12821 
 
12822 
  def __init__(self, success=None,):
12823 
    self.success = success
12824 
 
12825 
  def read(self, iprot):
12826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12828 
      return
12829 
    iprot.readStructBegin()
12830 
    while True:
12831 
      (fname, ftype, fid) = iprot.readFieldBegin()
12832 
      if ftype == TType.STOP:
12833 
        break
12834 
      if fid == 0:
12835 
        if ftype == TType.BOOL:
12836 
          self.success = iprot.readBool();
12837 
        else:
12838 
          iprot.skip(ftype)
12839 
      else:
12840 
        iprot.skip(ftype)
12841 
      iprot.readFieldEnd()
12842 
    iprot.readStructEnd()
12843 
 
12844 
  def write(self, oprot):
12845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12847 
      return
12848 
    oprot.writeStructBegin('addProductNotification_result')
12849 
    if self.success is not None:
12850 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12851 
      oprot.writeBool(self.success)
12852 
      oprot.writeFieldEnd()
12853 
    oprot.writeFieldStop()
12854 
    oprot.writeStructEnd()
12855 
 
12856 
  def validate(self):
12857 
    return
12858 
 
12859 
 
12860 
  def __repr__(self):
12861 
    L = ['%s=%r' % (key, value)
12862 
      for key, value in self.__dict__.iteritems()]
12863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12864 
 
12865 
  def __eq__(self, other):
12866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12867 
 
12868 
  def __ne__(self, other):
12869 
    return not (self == other)
12870 
 
12871 
class sendProductNotifications_args:
12872 
 
12873 
  thrift_spec = (
12874 
  )
12875 
 
12876 
  def read(self, iprot):
12877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12879 
      return
12880 
    iprot.readStructBegin()
12881 
    while True:
12882 
      (fname, ftype, fid) = iprot.readFieldBegin()
12883 
      if ftype == TType.STOP:
12884 
        break
12885 
      else:
12886 
        iprot.skip(ftype)
12887 
      iprot.readFieldEnd()
12888 
    iprot.readStructEnd()
12889 
 
12890 
  def write(self, oprot):
12891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12893 
      return
12894 
    oprot.writeStructBegin('sendProductNotifications_args')
12895 
    oprot.writeFieldStop()
12896 
    oprot.writeStructEnd()
12897 
 
12898 
  def validate(self):
12899 
    return
12900 
 
12901 
 
12902 
  def __repr__(self):
12903 
    L = ['%s=%r' % (key, value)
12904 
      for key, value in self.__dict__.iteritems()]
12905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12906 
 
12907 
  def __eq__(self, other):
12908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12909 
 
12910 
  def __ne__(self, other):
12911 
    return not (self == other)
12912 
 
12913 
class sendProductNotifications_result:
12914 
  """
12915 
  Attributes:
12916 
   - success
12917 
  """
12918 
 
12919 
  thrift_spec = (
12920 
    (0, TType.BOOL, 'success', None, None, ), # 0
12921 
  )
12922 
 
12923 
  def __init__(self, success=None,):
12924 
    self.success = success
12925 
 
12926 
  def read(self, iprot):
12927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12929 
      return
12930 
    iprot.readStructBegin()
12931 
    while True:
12932 
      (fname, ftype, fid) = iprot.readFieldBegin()
12933 
      if ftype == TType.STOP:
12934 
        break
12935 
      if fid == 0:
12936 
        if ftype == TType.BOOL:
12937 
          self.success = iprot.readBool();
12938 
        else:
12939 
          iprot.skip(ftype)
12940 
      else:
12941 
        iprot.skip(ftype)
12942 
      iprot.readFieldEnd()
12943 
    iprot.readStructEnd()
12944 
 
12945 
  def write(self, oprot):
12946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12948 
      return
12949 
    oprot.writeStructBegin('sendProductNotifications_result')
12950 
    if self.success is not None:
12951 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12952 
      oprot.writeBool(self.success)
12953 
      oprot.writeFieldEnd()
12954 
    oprot.writeFieldStop()
12955 
    oprot.writeStructEnd()
12956 
 
12957 
  def validate(self):
12958 
    return
12959 
 
12960 
 
12961 
  def __repr__(self):
12962 
    L = ['%s=%r' % (key, value)
12963 
      for key, value in self.__dict__.iteritems()]
12964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12965 
 
12966 
  def __eq__(self, other):
12967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12968 
 
12969 
  def __ne__(self, other):
12970 
    return not (self == other)
12971 
 
12972 
class getAllBrandsByCategory_args:
12973 
  """
12974 
  Attributes:
12975 
   - categoryId
12976 
  """
12977 
 
12978 
  thrift_spec = (
12979 
    None, # 0
12980 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12981 
  )
12982 
 
12983 
  def __init__(self, categoryId=None,):
12984 
    self.categoryId = categoryId
12985 
 
12986 
  def read(self, iprot):
12987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12989 
      return
12990 
    iprot.readStructBegin()
12991 
    while True:
12992 
      (fname, ftype, fid) = iprot.readFieldBegin()
12993 
      if ftype == TType.STOP:
12994 
        break
12995 
      if fid == 1:
12996 
        if ftype == TType.I64:
12997 
          self.categoryId = iprot.readI64();
12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
13010 
    if self.categoryId is not None:
13011 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
13012 
      oprot.writeI64(self.categoryId)
13013 
      oprot.writeFieldEnd()
13014 
    oprot.writeFieldStop()
13015 
    oprot.writeStructEnd()
13016 
 
13017 
  def validate(self):
13018 
    return
13019 
 
13020 
 
13021 
  def __repr__(self):
13022 
    L = ['%s=%r' % (key, value)
13023 
      for key, value in self.__dict__.iteritems()]
13024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13025 
 
13026 
  def __eq__(self, other):
13027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13028 
 
13029 
  def __ne__(self, other):
13030 
    return not (self == other)
13031 
 
13032 
class getAllBrandsByCategory_result:
13033 
  """
13034 
  Attributes:
13035 
   - success
13036 
  """
13037 
 
13038 
  thrift_spec = (
13039 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13040 
  )
13041 
 
13042 
  def __init__(self, success=None,):
13043 
    self.success = success
13044 
 
13045 
  def read(self, iprot):
13046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13048 
      return
13049 
    iprot.readStructBegin()
13050 
    while True:
13051 
      (fname, ftype, fid) = iprot.readFieldBegin()
13052 
      if ftype == TType.STOP:
13053 
        break
13054 
      if fid == 0:
13055 
        if ftype == TType.LIST:
13056 
          self.success = []
7438 amit.gupta 13057 
          (_etype226, _size223) = iprot.readListBegin()
13058 
          for _i227 in xrange(_size223):
13059 
            _elem228 = iprot.readString();
13060 
            self.success.append(_elem228)
5944 mandeep.dh 13061 
          iprot.readListEnd()
13062 
        else:
13063 
          iprot.skip(ftype)
13064 
      else:
13065 
        iprot.skip(ftype)
13066 
      iprot.readFieldEnd()
13067 
    iprot.readStructEnd()
13068 
 
13069 
  def write(self, oprot):
13070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13072 
      return
13073 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
13074 
    if self.success is not None:
13075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13076 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13077 
      for iter229 in self.success:
13078 
        oprot.writeString(iter229)
5944 mandeep.dh 13079 
      oprot.writeListEnd()
13080 
      oprot.writeFieldEnd()
13081 
    oprot.writeFieldStop()
13082 
    oprot.writeStructEnd()
13083 
 
13084 
  def validate(self):
13085 
    return
13086 
 
13087 
 
13088 
  def __repr__(self):
13089 
    L = ['%s=%r' % (key, value)
13090 
      for key, value in self.__dict__.iteritems()]
13091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13092 
 
13093 
  def __eq__(self, other):
13094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13095 
 
13096 
  def __ne__(self, other):
13097 
    return not (self == other)
13098 
 
13099 
class getAllBrands_args:
13100 
 
13101 
  thrift_spec = (
13102 
  )
13103 
 
13104 
  def read(self, iprot):
13105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13107 
      return
13108 
    iprot.readStructBegin()
13109 
    while True:
13110 
      (fname, ftype, fid) = iprot.readFieldBegin()
13111 
      if ftype == TType.STOP:
13112 
        break
13113 
      else:
13114 
        iprot.skip(ftype)
13115 
      iprot.readFieldEnd()
13116 
    iprot.readStructEnd()
13117 
 
13118 
  def write(self, oprot):
13119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13121 
      return
13122 
    oprot.writeStructBegin('getAllBrands_args')
13123 
    oprot.writeFieldStop()
13124 
    oprot.writeStructEnd()
13125 
 
13126 
  def validate(self):
13127 
    return
13128 
 
13129 
 
13130 
  def __repr__(self):
13131 
    L = ['%s=%r' % (key, value)
13132 
      for key, value in self.__dict__.iteritems()]
13133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13134 
 
13135 
  def __eq__(self, other):
13136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13137 
 
13138 
  def __ne__(self, other):
13139 
    return not (self == other)
13140 
 
13141 
class getAllBrands_result:
13142 
  """
13143 
  Attributes:
13144 
   - success
13145 
  """
13146 
 
13147 
  thrift_spec = (
13148 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13149 
  )
13150 
 
13151 
  def __init__(self, success=None,):
13152 
    self.success = success
13153 
 
13154 
  def read(self, iprot):
13155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13157 
      return
13158 
    iprot.readStructBegin()
13159 
    while True:
13160 
      (fname, ftype, fid) = iprot.readFieldBegin()
13161 
      if ftype == TType.STOP:
13162 
        break
13163 
      if fid == 0:
13164 
        if ftype == TType.LIST:
13165 
          self.success = []
7438 amit.gupta 13166 
          (_etype233, _size230) = iprot.readListBegin()
13167 
          for _i234 in xrange(_size230):
13168 
            _elem235 = iprot.readString();
13169 
            self.success.append(_elem235)
5944 mandeep.dh 13170 
          iprot.readListEnd()
13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      else:
13174 
        iprot.skip(ftype)
13175 
      iprot.readFieldEnd()
13176 
    iprot.readStructEnd()
13177 
 
13178 
  def write(self, oprot):
13179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13181 
      return
13182 
    oprot.writeStructBegin('getAllBrands_result')
13183 
    if self.success is not None:
13184 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13185 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13186 
      for iter236 in self.success:
13187 
        oprot.writeString(iter236)
5944 mandeep.dh 13188 
      oprot.writeListEnd()
13189 
      oprot.writeFieldEnd()
13190 
    oprot.writeFieldStop()
13191 
    oprot.writeStructEnd()
13192 
 
13193 
  def validate(self):
13194 
    return
13195 
 
13196 
 
13197 
  def __repr__(self):
13198 
    L = ['%s=%r' % (key, value)
13199 
      for key, value in self.__dict__.iteritems()]
13200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13201 
 
13202 
  def __eq__(self, other):
13203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13204 
 
13205 
  def __ne__(self, other):
13206 
    return not (self == other)
13207 
 
13208 
class getAllSources_args:
13209 
 
13210 
  thrift_spec = (
13211 
  )
13212 
 
13213 
  def read(self, iprot):
13214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13216 
      return
13217 
    iprot.readStructBegin()
13218 
    while True:
13219 
      (fname, ftype, fid) = iprot.readFieldBegin()
13220 
      if ftype == TType.STOP:
13221 
        break
13222 
      else:
13223 
        iprot.skip(ftype)
13224 
      iprot.readFieldEnd()
13225 
    iprot.readStructEnd()
13226 
 
13227 
  def write(self, oprot):
13228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13230 
      return
13231 
    oprot.writeStructBegin('getAllSources_args')
13232 
    oprot.writeFieldStop()
13233 
    oprot.writeStructEnd()
13234 
 
13235 
  def validate(self):
13236 
    return
13237 
 
13238 
 
13239 
  def __repr__(self):
13240 
    L = ['%s=%r' % (key, value)
13241 
      for key, value in self.__dict__.iteritems()]
13242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13243 
 
13244 
  def __eq__(self, other):
13245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13246 
 
13247 
  def __ne__(self, other):
13248 
    return not (self == other)
13249 
 
13250 
class getAllSources_result:
13251 
  """
13252 
  Attributes:
13253 
   - success
13254 
  """
13255 
 
13256 
  thrift_spec = (
13257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13258 
  )
13259 
 
13260 
  def __init__(self, success=None,):
13261 
    self.success = success
13262 
 
13263 
  def read(self, iprot):
13264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13266 
      return
13267 
    iprot.readStructBegin()
13268 
    while True:
13269 
      (fname, ftype, fid) = iprot.readFieldBegin()
13270 
      if ftype == TType.STOP:
13271 
        break
13272 
      if fid == 0:
13273 
        if ftype == TType.LIST:
13274 
          self.success = []
7438 amit.gupta 13275 
          (_etype240, _size237) = iprot.readListBegin()
13276 
          for _i241 in xrange(_size237):
13277 
            _elem242 = Source()
13278 
            _elem242.read(iprot)
13279 
            self.success.append(_elem242)
5944 mandeep.dh 13280 
          iprot.readListEnd()
13281 
        else:
13282 
          iprot.skip(ftype)
13283 
      else:
13284 
        iprot.skip(ftype)
13285 
      iprot.readFieldEnd()
13286 
    iprot.readStructEnd()
13287 
 
13288 
  def write(self, oprot):
13289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13291 
      return
13292 
    oprot.writeStructBegin('getAllSources_result')
13293 
    if self.success is not None:
13294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13296 
      for iter243 in self.success:
13297 
        iter243.write(oprot)
5944 mandeep.dh 13298 
      oprot.writeListEnd()
13299 
      oprot.writeFieldEnd()
13300 
    oprot.writeFieldStop()
13301 
    oprot.writeStructEnd()
13302 
 
13303 
  def validate(self):
13304 
    return
13305 
 
13306 
 
13307 
  def __repr__(self):
13308 
    L = ['%s=%r' % (key, value)
13309 
      for key, value in self.__dict__.iteritems()]
13310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13311 
 
13312 
  def __eq__(self, other):
13313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13314 
 
13315 
  def __ne__(self, other):
13316 
    return not (self == other)
13317 
 
13318 
class getItemPricingBySource_args:
13319 
  """
13320 
  Attributes:
13321 
   - itemId
13322 
   - sourceId
13323 
  """
13324 
 
13325 
  thrift_spec = (
13326 
    None, # 0
13327 
    (1, TType.I64, 'itemId', None, None, ), # 1
13328 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13329 
  )
13330 
 
13331 
  def __init__(self, itemId=None, sourceId=None,):
13332 
    self.itemId = itemId
13333 
    self.sourceId = sourceId
13334 
 
13335 
  def read(self, iprot):
13336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13338 
      return
13339 
    iprot.readStructBegin()
13340 
    while True:
13341 
      (fname, ftype, fid) = iprot.readFieldBegin()
13342 
      if ftype == TType.STOP:
13343 
        break
13344 
      if fid == 1:
13345 
        if ftype == TType.I64:
13346 
          self.itemId = iprot.readI64();
13347 
        else:
13348 
          iprot.skip(ftype)
13349 
      elif fid == 2:
13350 
        if ftype == TType.I64:
13351 
          self.sourceId = iprot.readI64();
13352 
        else:
13353 
          iprot.skip(ftype)
13354 
      else:
13355 
        iprot.skip(ftype)
13356 
      iprot.readFieldEnd()
13357 
    iprot.readStructEnd()
13358 
 
13359 
  def write(self, oprot):
13360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13362 
      return
13363 
    oprot.writeStructBegin('getItemPricingBySource_args')
13364 
    if self.itemId is not None:
13365 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13366 
      oprot.writeI64(self.itemId)
13367 
      oprot.writeFieldEnd()
13368 
    if self.sourceId is not None:
13369 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13370 
      oprot.writeI64(self.sourceId)
13371 
      oprot.writeFieldEnd()
13372 
    oprot.writeFieldStop()
13373 
    oprot.writeStructEnd()
13374 
 
13375 
  def validate(self):
13376 
    return
13377 
 
13378 
 
13379 
  def __repr__(self):
13380 
    L = ['%s=%r' % (key, value)
13381 
      for key, value in self.__dict__.iteritems()]
13382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13383 
 
13384 
  def __eq__(self, other):
13385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13386 
 
13387 
  def __ne__(self, other):
13388 
    return not (self == other)
13389 
 
13390 
class getItemPricingBySource_result:
13391 
  """
13392 
  Attributes:
13393 
   - success
13394 
   - cex
13395 
  """
13396 
 
13397 
  thrift_spec = (
13398 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13399 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13400 
  )
13401 
 
13402 
  def __init__(self, success=None, cex=None,):
13403 
    self.success = success
13404 
    self.cex = cex
13405 
 
13406 
  def read(self, iprot):
13407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13409 
      return
13410 
    iprot.readStructBegin()
13411 
    while True:
13412 
      (fname, ftype, fid) = iprot.readFieldBegin()
13413 
      if ftype == TType.STOP:
13414 
        break
13415 
      if fid == 0:
13416 
        if ftype == TType.STRUCT:
13417 
          self.success = SourceItemPricing()
13418 
          self.success.read(iprot)
13419 
        else:
13420 
          iprot.skip(ftype)
13421 
      elif fid == 1:
13422 
        if ftype == TType.STRUCT:
13423 
          self.cex = CatalogServiceException()
13424 
          self.cex.read(iprot)
13425 
        else:
13426 
          iprot.skip(ftype)
13427 
      else:
13428 
        iprot.skip(ftype)
13429 
      iprot.readFieldEnd()
13430 
    iprot.readStructEnd()
13431 
 
13432 
  def write(self, oprot):
13433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13435 
      return
13436 
    oprot.writeStructBegin('getItemPricingBySource_result')
13437 
    if self.success is not None:
13438 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13439 
      self.success.write(oprot)
13440 
      oprot.writeFieldEnd()
13441 
    if self.cex is not None:
13442 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13443 
      self.cex.write(oprot)
13444 
      oprot.writeFieldEnd()
13445 
    oprot.writeFieldStop()
13446 
    oprot.writeStructEnd()
13447 
 
13448 
  def validate(self):
13449 
    return
13450 
 
13451 
 
13452 
  def __repr__(self):
13453 
    L = ['%s=%r' % (key, value)
13454 
      for key, value in self.__dict__.iteritems()]
13455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13456 
 
13457 
  def __eq__(self, other):
13458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13459 
 
13460 
  def __ne__(self, other):
13461 
    return not (self == other)
13462 
 
13463 
class addSourceItemPricing_args:
13464 
  """
13465 
  Attributes:
13466 
   - sourceItemPricing
13467 
  """
13468 
 
13469 
  thrift_spec = (
13470 
    None, # 0
13471 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13472 
  )
13473 
 
13474 
  def __init__(self, sourceItemPricing=None,):
13475 
    self.sourceItemPricing = sourceItemPricing
13476 
 
13477 
  def read(self, iprot):
13478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13480 
      return
13481 
    iprot.readStructBegin()
13482 
    while True:
13483 
      (fname, ftype, fid) = iprot.readFieldBegin()
13484 
      if ftype == TType.STOP:
13485 
        break
13486 
      if fid == 1:
13487 
        if ftype == TType.STRUCT:
13488 
          self.sourceItemPricing = SourceItemPricing()
13489 
          self.sourceItemPricing.read(iprot)
13490 
        else:
13491 
          iprot.skip(ftype)
13492 
      else:
13493 
        iprot.skip(ftype)
13494 
      iprot.readFieldEnd()
13495 
    iprot.readStructEnd()
13496 
 
13497 
  def write(self, oprot):
13498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13500 
      return
13501 
    oprot.writeStructBegin('addSourceItemPricing_args')
13502 
    if self.sourceItemPricing is not None:
13503 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13504 
      self.sourceItemPricing.write(oprot)
13505 
      oprot.writeFieldEnd()
13506 
    oprot.writeFieldStop()
13507 
    oprot.writeStructEnd()
13508 
 
13509 
  def validate(self):
13510 
    return
13511 
 
13512 
 
13513 
  def __repr__(self):
13514 
    L = ['%s=%r' % (key, value)
13515 
      for key, value in self.__dict__.iteritems()]
13516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13517 
 
13518 
  def __eq__(self, other):
13519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13520 
 
13521 
  def __ne__(self, other):
13522 
    return not (self == other)
13523 
 
13524 
class addSourceItemPricing_result:
13525 
  """
13526 
  Attributes:
13527 
   - cex
13528 
  """
13529 
 
13530 
  thrift_spec = (
13531 
    None, # 0
13532 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13533 
  )
13534 
 
13535 
  def __init__(self, cex=None,):
13536 
    self.cex = cex
13537 
 
13538 
  def read(self, iprot):
13539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13541 
      return
13542 
    iprot.readStructBegin()
13543 
    while True:
13544 
      (fname, ftype, fid) = iprot.readFieldBegin()
13545 
      if ftype == TType.STOP:
13546 
        break
13547 
      if fid == 1:
13548 
        if ftype == TType.STRUCT:
13549 
          self.cex = CatalogServiceException()
13550 
          self.cex.read(iprot)
13551 
        else:
13552 
          iprot.skip(ftype)
13553 
      else:
13554 
        iprot.skip(ftype)
13555 
      iprot.readFieldEnd()
13556 
    iprot.readStructEnd()
13557 
 
13558 
  def write(self, oprot):
13559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13561 
      return
13562 
    oprot.writeStructBegin('addSourceItemPricing_result')
13563 
    if self.cex is not None:
13564 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13565 
      self.cex.write(oprot)
13566 
      oprot.writeFieldEnd()
13567 
    oprot.writeFieldStop()
13568 
    oprot.writeStructEnd()
13569 
 
13570 
  def validate(self):
13571 
    return
13572 
 
13573 
 
13574 
  def __repr__(self):
13575 
    L = ['%s=%r' % (key, value)
13576 
      for key, value in self.__dict__.iteritems()]
13577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13578 
 
13579 
  def __eq__(self, other):
13580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13581 
 
13582 
  def __ne__(self, other):
13583 
    return not (self == other)
13584 
 
13585 
class getAllSourcePricing_args:
13586 
  """
13587 
  Attributes:
13588 
   - itemId
13589 
  """
13590 
 
13591 
  thrift_spec = (
13592 
    None, # 0
13593 
    (1, TType.I64, 'itemId', None, None, ), # 1
13594 
  )
13595 
 
13596 
  def __init__(self, itemId=None,):
13597 
    self.itemId = itemId
13598 
 
13599 
  def read(self, iprot):
13600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13602 
      return
13603 
    iprot.readStructBegin()
13604 
    while True:
13605 
      (fname, ftype, fid) = iprot.readFieldBegin()
13606 
      if ftype == TType.STOP:
13607 
        break
13608 
      if fid == 1:
13609 
        if ftype == TType.I64:
13610 
          self.itemId = iprot.readI64();
13611 
        else:
13612 
          iprot.skip(ftype)
13613 
      else:
13614 
        iprot.skip(ftype)
13615 
      iprot.readFieldEnd()
13616 
    iprot.readStructEnd()
13617 
 
13618 
  def write(self, oprot):
13619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13621 
      return
13622 
    oprot.writeStructBegin('getAllSourcePricing_args')
13623 
    if self.itemId is not None:
13624 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13625 
      oprot.writeI64(self.itemId)
13626 
      oprot.writeFieldEnd()
13627 
    oprot.writeFieldStop()
13628 
    oprot.writeStructEnd()
13629 
 
13630 
  def validate(self):
13631 
    return
13632 
 
13633 
 
13634 
  def __repr__(self):
13635 
    L = ['%s=%r' % (key, value)
13636 
      for key, value in self.__dict__.iteritems()]
13637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13638 
 
13639 
  def __eq__(self, other):
13640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13641 
 
13642 
  def __ne__(self, other):
13643 
    return not (self == other)
13644 
 
13645 
class getAllSourcePricing_result:
13646 
  """
13647 
  Attributes:
13648 
   - success
13649 
   - cex
13650 
  """
13651 
 
13652 
  thrift_spec = (
13653 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13654 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13655 
  )
13656 
 
13657 
  def __init__(self, success=None, cex=None,):
13658 
    self.success = success
13659 
    self.cex = cex
13660 
 
13661 
  def read(self, iprot):
13662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13664 
      return
13665 
    iprot.readStructBegin()
13666 
    while True:
13667 
      (fname, ftype, fid) = iprot.readFieldBegin()
13668 
      if ftype == TType.STOP:
13669 
        break
13670 
      if fid == 0:
13671 
        if ftype == TType.LIST:
13672 
          self.success = []
7438 amit.gupta 13673 
          (_etype247, _size244) = iprot.readListBegin()
13674 
          for _i248 in xrange(_size244):
13675 
            _elem249 = SourceItemPricing()
13676 
            _elem249.read(iprot)
13677 
            self.success.append(_elem249)
5944 mandeep.dh 13678 
          iprot.readListEnd()
13679 
        else:
13680 
          iprot.skip(ftype)
13681 
      elif fid == 1:
13682 
        if ftype == TType.STRUCT:
13683 
          self.cex = CatalogServiceException()
13684 
          self.cex.read(iprot)
13685 
        else:
13686 
          iprot.skip(ftype)
13687 
      else:
13688 
        iprot.skip(ftype)
13689 
      iprot.readFieldEnd()
13690 
    iprot.readStructEnd()
13691 
 
13692 
  def write(self, oprot):
13693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13695 
      return
13696 
    oprot.writeStructBegin('getAllSourcePricing_result')
13697 
    if self.success is not None:
13698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13700 
      for iter250 in self.success:
13701 
        iter250.write(oprot)
5944 mandeep.dh 13702 
      oprot.writeListEnd()
13703 
      oprot.writeFieldEnd()
13704 
    if self.cex is not None:
13705 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13706 
      self.cex.write(oprot)
13707 
      oprot.writeFieldEnd()
13708 
    oprot.writeFieldStop()
13709 
    oprot.writeStructEnd()
13710 
 
13711 
  def validate(self):
13712 
    return
13713 
 
13714 
 
13715 
  def __repr__(self):
13716 
    L = ['%s=%r' % (key, value)
13717 
      for key, value in self.__dict__.iteritems()]
13718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13719 
 
13720 
  def __eq__(self, other):
13721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13722 
 
13723 
  def __ne__(self, other):
13724 
    return not (self == other)
13725 
 
13726 
class getItemForSource_args:
13727 
  """
13728 
  Attributes:
13729 
   - item_id
13730 
   - sourceId
13731 
  """
13732 
 
13733 
  thrift_spec = (
13734 
    None, # 0
13735 
    (1, TType.I64, 'item_id', None, None, ), # 1
13736 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13737 
  )
13738 
 
13739 
  def __init__(self, item_id=None, sourceId=None,):
13740 
    self.item_id = item_id
13741 
    self.sourceId = sourceId
13742 
 
13743 
  def read(self, iprot):
13744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13746 
      return
13747 
    iprot.readStructBegin()
13748 
    while True:
13749 
      (fname, ftype, fid) = iprot.readFieldBegin()
13750 
      if ftype == TType.STOP:
13751 
        break
13752 
      if fid == 1:
13753 
        if ftype == TType.I64:
13754 
          self.item_id = iprot.readI64();
13755 
        else:
13756 
          iprot.skip(ftype)
13757 
      elif fid == 2:
13758 
        if ftype == TType.I64:
13759 
          self.sourceId = iprot.readI64();
13760 
        else:
13761 
          iprot.skip(ftype)
13762 
      else:
13763 
        iprot.skip(ftype)
13764 
      iprot.readFieldEnd()
13765 
    iprot.readStructEnd()
13766 
 
13767 
  def write(self, oprot):
13768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13770 
      return
13771 
    oprot.writeStructBegin('getItemForSource_args')
13772 
    if self.item_id is not None:
13773 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13774 
      oprot.writeI64(self.item_id)
13775 
      oprot.writeFieldEnd()
13776 
    if self.sourceId is not None:
13777 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13778 
      oprot.writeI64(self.sourceId)
13779 
      oprot.writeFieldEnd()
13780 
    oprot.writeFieldStop()
13781 
    oprot.writeStructEnd()
13782 
 
13783 
  def validate(self):
13784 
    return
13785 
 
13786 
 
13787 
  def __repr__(self):
13788 
    L = ['%s=%r' % (key, value)
13789 
      for key, value in self.__dict__.iteritems()]
13790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13791 
 
13792 
  def __eq__(self, other):
13793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13794 
 
13795 
  def __ne__(self, other):
13796 
    return not (self == other)
13797 
 
13798 
class getItemForSource_result:
13799 
  """
13800 
  Attributes:
13801 
   - success
13802 
   - cex
13803 
  """
13804 
 
13805 
  thrift_spec = (
13806 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13807 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13808 
  )
13809 
 
13810 
  def __init__(self, success=None, cex=None,):
13811 
    self.success = success
13812 
    self.cex = cex
13813 
 
13814 
  def read(self, iprot):
13815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13817 
      return
13818 
    iprot.readStructBegin()
13819 
    while True:
13820 
      (fname, ftype, fid) = iprot.readFieldBegin()
13821 
      if ftype == TType.STOP:
13822 
        break
13823 
      if fid == 0:
13824 
        if ftype == TType.STRUCT:
13825 
          self.success = Item()
13826 
          self.success.read(iprot)
13827 
        else:
13828 
          iprot.skip(ftype)
13829 
      elif fid == 1:
13830 
        if ftype == TType.STRUCT:
13831 
          self.cex = CatalogServiceException()
13832 
          self.cex.read(iprot)
13833 
        else:
13834 
          iprot.skip(ftype)
13835 
      else:
13836 
        iprot.skip(ftype)
13837 
      iprot.readFieldEnd()
13838 
    iprot.readStructEnd()
13839 
 
13840 
  def write(self, oprot):
13841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13843 
      return
13844 
    oprot.writeStructBegin('getItemForSource_result')
13845 
    if self.success is not None:
13846 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13847 
      self.success.write(oprot)
13848 
      oprot.writeFieldEnd()
13849 
    if self.cex is not None:
13850 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13851 
      self.cex.write(oprot)
13852 
      oprot.writeFieldEnd()
13853 
    oprot.writeFieldStop()
13854 
    oprot.writeStructEnd()
13855 
 
13856 
  def validate(self):
13857 
    return
13858 
 
13859 
 
13860 
  def __repr__(self):
13861 
    L = ['%s=%r' % (key, value)
13862 
      for key, value in self.__dict__.iteritems()]
13863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13864 
 
13865 
  def __eq__(self, other):
13866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13867 
 
13868 
  def __ne__(self, other):
13869 
    return not (self == other)
13870 
 
13871 
class searchItemsInRange_args:
13872 
  """
13873 
  Attributes:
13874 
   - searchTerms
13875 
   - offset
13876 
   - limit
13877 
  """
13878 
 
13879 
  thrift_spec = (
13880 
    None, # 0
13881 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13882 
    (2, TType.I64, 'offset', None, None, ), # 2
13883 
    (3, TType.I64, 'limit', None, None, ), # 3
13884 
  )
13885 
 
13886 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13887 
    self.searchTerms = searchTerms
13888 
    self.offset = offset
13889 
    self.limit = limit
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      if fid == 1:
13901 
        if ftype == TType.LIST:
13902 
          self.searchTerms = []
7438 amit.gupta 13903 
          (_etype254, _size251) = iprot.readListBegin()
13904 
          for _i255 in xrange(_size251):
13905 
            _elem256 = iprot.readString();
13906 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 13907 
          iprot.readListEnd()
13908 
        else:
13909 
          iprot.skip(ftype)
13910 
      elif fid == 2:
13911 
        if ftype == TType.I64:
13912 
          self.offset = iprot.readI64();
13913 
        else:
13914 
          iprot.skip(ftype)
13915 
      elif fid == 3:
13916 
        if ftype == TType.I64:
13917 
          self.limit = iprot.readI64();
13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
13929 
    oprot.writeStructBegin('searchItemsInRange_args')
13930 
    if self.searchTerms is not None:
13931 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13932 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 13933 
      for iter257 in self.searchTerms:
13934 
        oprot.writeString(iter257)
5944 mandeep.dh 13935 
      oprot.writeListEnd()
13936 
      oprot.writeFieldEnd()
13937 
    if self.offset is not None:
13938 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13939 
      oprot.writeI64(self.offset)
13940 
      oprot.writeFieldEnd()
13941 
    if self.limit is not None:
13942 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13943 
      oprot.writeI64(self.limit)
13944 
      oprot.writeFieldEnd()
13945 
    oprot.writeFieldStop()
13946 
    oprot.writeStructEnd()
13947 
 
13948 
  def validate(self):
13949 
    return
13950 
 
13951 
 
13952 
  def __repr__(self):
13953 
    L = ['%s=%r' % (key, value)
13954 
      for key, value in self.__dict__.iteritems()]
13955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13956 
 
13957 
  def __eq__(self, other):
13958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13959 
 
13960 
  def __ne__(self, other):
13961 
    return not (self == other)
13962 
 
13963 
class searchItemsInRange_result:
13964 
  """
13965 
  Attributes:
13966 
   - success
13967 
  """
13968 
 
13969 
  thrift_spec = (
13970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13971 
  )
13972 
 
13973 
  def __init__(self, success=None,):
13974 
    self.success = success
13975 
 
13976 
  def read(self, iprot):
13977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13979 
      return
13980 
    iprot.readStructBegin()
13981 
    while True:
13982 
      (fname, ftype, fid) = iprot.readFieldBegin()
13983 
      if ftype == TType.STOP:
13984 
        break
13985 
      if fid == 0:
13986 
        if ftype == TType.LIST:
13987 
          self.success = []
7438 amit.gupta 13988 
          (_etype261, _size258) = iprot.readListBegin()
13989 
          for _i262 in xrange(_size258):
13990 
            _elem263 = Item()
13991 
            _elem263.read(iprot)
13992 
            self.success.append(_elem263)
5944 mandeep.dh 13993 
          iprot.readListEnd()
13994 
        else:
13995 
          iprot.skip(ftype)
13996 
      else:
13997 
        iprot.skip(ftype)
13998 
      iprot.readFieldEnd()
13999 
    iprot.readStructEnd()
14000 
 
14001 
  def write(self, oprot):
14002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14004 
      return
14005 
    oprot.writeStructBegin('searchItemsInRange_result')
14006 
    if self.success is not None:
14007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14009 
      for iter264 in self.success:
14010 
        iter264.write(oprot)
5944 mandeep.dh 14011 
      oprot.writeListEnd()
14012 
      oprot.writeFieldEnd()
14013 
    oprot.writeFieldStop()
14014 
    oprot.writeStructEnd()
14015 
 
14016 
  def validate(self):
14017 
    return
14018 
 
14019 
 
14020 
  def __repr__(self):
14021 
    L = ['%s=%r' % (key, value)
14022 
      for key, value in self.__dict__.iteritems()]
14023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14024 
 
14025 
  def __eq__(self, other):
14026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14027 
 
14028 
  def __ne__(self, other):
14029 
    return not (self == other)
14030 
 
14031 
class getSearchResultCount_args:
14032 
  """
14033 
  Attributes:
14034 
   - searchTerms
14035 
  """
14036 
 
14037 
  thrift_spec = (
14038 
    None, # 0
14039 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14040 
  )
14041 
 
14042 
  def __init__(self, searchTerms=None,):
14043 
    self.searchTerms = searchTerms
14044 
 
14045 
  def read(self, iprot):
14046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14048 
      return
14049 
    iprot.readStructBegin()
14050 
    while True:
14051 
      (fname, ftype, fid) = iprot.readFieldBegin()
14052 
      if ftype == TType.STOP:
14053 
        break
14054 
      if fid == 1:
14055 
        if ftype == TType.LIST:
14056 
          self.searchTerms = []
7438 amit.gupta 14057 
          (_etype268, _size265) = iprot.readListBegin()
14058 
          for _i269 in xrange(_size265):
14059 
            _elem270 = iprot.readString();
14060 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14061 
          iprot.readListEnd()
14062 
        else:
14063 
          iprot.skip(ftype)
14064 
      else:
14065 
        iprot.skip(ftype)
14066 
      iprot.readFieldEnd()
14067 
    iprot.readStructEnd()
14068 
 
14069 
  def write(self, oprot):
14070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14072 
      return
14073 
    oprot.writeStructBegin('getSearchResultCount_args')
14074 
    if self.searchTerms is not None:
14075 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14076 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14077 
      for iter271 in self.searchTerms:
14078 
        oprot.writeString(iter271)
5944 mandeep.dh 14079 
      oprot.writeListEnd()
14080 
      oprot.writeFieldEnd()
14081 
    oprot.writeFieldStop()
14082 
    oprot.writeStructEnd()
14083 
 
14084 
  def validate(self):
14085 
    return
14086 
 
14087 
 
14088 
  def __repr__(self):
14089 
    L = ['%s=%r' % (key, value)
14090 
      for key, value in self.__dict__.iteritems()]
14091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14092 
 
14093 
  def __eq__(self, other):
14094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14095 
 
14096 
  def __ne__(self, other):
14097 
    return not (self == other)
14098 
 
14099 
class getSearchResultCount_result:
14100 
  """
14101 
  Attributes:
14102 
   - success
14103 
  """
14104 
 
14105 
  thrift_spec = (
14106 
    (0, TType.I32, 'success', None, None, ), # 0
14107 
  )
14108 
 
14109 
  def __init__(self, success=None,):
14110 
    self.success = success
14111 
 
14112 
  def read(self, iprot):
14113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14115 
      return
14116 
    iprot.readStructBegin()
14117 
    while True:
14118 
      (fname, ftype, fid) = iprot.readFieldBegin()
14119 
      if ftype == TType.STOP:
14120 
        break
14121 
      if fid == 0:
14122 
        if ftype == TType.I32:
14123 
          self.success = iprot.readI32();
14124 
        else:
14125 
          iprot.skip(ftype)
14126 
      else:
14127 
        iprot.skip(ftype)
14128 
      iprot.readFieldEnd()
14129 
    iprot.readStructEnd()
14130 
 
14131 
  def write(self, oprot):
14132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14134 
      return
14135 
    oprot.writeStructBegin('getSearchResultCount_result')
14136 
    if self.success is not None:
14137 
      oprot.writeFieldBegin('success', TType.I32, 0)
14138 
      oprot.writeI32(self.success)
14139 
      oprot.writeFieldEnd()
14140 
    oprot.writeFieldStop()
14141 
    oprot.writeStructEnd()
14142 
 
14143 
  def validate(self):
14144 
    return
14145 
 
14146 
 
14147 
  def __repr__(self):
14148 
    L = ['%s=%r' % (key, value)
14149 
      for key, value in self.__dict__.iteritems()]
14150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14151 
 
14152 
  def __eq__(self, other):
14153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14154 
 
14155 
  def __ne__(self, other):
14156 
    return not (self == other)
14157 
 
14158 
class getProductNotifications_args:
14159 
  """
14160 
  Attributes:
14161 
   - startDateTime
14162 
  """
14163 
 
14164 
  thrift_spec = (
14165 
    None, # 0
14166 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14167 
  )
14168 
 
14169 
  def __init__(self, startDateTime=None,):
14170 
    self.startDateTime = startDateTime
14171 
 
14172 
  def read(self, iprot):
14173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14175 
      return
14176 
    iprot.readStructBegin()
14177 
    while True:
14178 
      (fname, ftype, fid) = iprot.readFieldBegin()
14179 
      if ftype == TType.STOP:
14180 
        break
14181 
      if fid == 1:
14182 
        if ftype == TType.I64:
14183 
          self.startDateTime = iprot.readI64();
14184 
        else:
14185 
          iprot.skip(ftype)
14186 
      else:
14187 
        iprot.skip(ftype)
14188 
      iprot.readFieldEnd()
14189 
    iprot.readStructEnd()
14190 
 
14191 
  def write(self, oprot):
14192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14194 
      return
14195 
    oprot.writeStructBegin('getProductNotifications_args')
14196 
    if self.startDateTime is not None:
14197 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14198 
      oprot.writeI64(self.startDateTime)
14199 
      oprot.writeFieldEnd()
14200 
    oprot.writeFieldStop()
14201 
    oprot.writeStructEnd()
14202 
 
14203 
  def validate(self):
14204 
    return
14205 
 
14206 
 
14207 
  def __repr__(self):
14208 
    L = ['%s=%r' % (key, value)
14209 
      for key, value in self.__dict__.iteritems()]
14210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14211 
 
14212 
  def __eq__(self, other):
14213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14214 
 
14215 
  def __ne__(self, other):
14216 
    return not (self == other)
14217 
 
14218 
class getProductNotifications_result:
14219 
  """
14220 
  Attributes:
14221 
   - success
14222 
  """
14223 
 
14224 
  thrift_spec = (
14225 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14226 
  )
14227 
 
14228 
  def __init__(self, success=None,):
14229 
    self.success = success
14230 
 
14231 
  def read(self, iprot):
14232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14234 
      return
14235 
    iprot.readStructBegin()
14236 
    while True:
14237 
      (fname, ftype, fid) = iprot.readFieldBegin()
14238 
      if ftype == TType.STOP:
14239 
        break
14240 
      if fid == 0:
14241 
        if ftype == TType.LIST:
14242 
          self.success = []
7438 amit.gupta 14243 
          (_etype275, _size272) = iprot.readListBegin()
14244 
          for _i276 in xrange(_size272):
14245 
            _elem277 = ProductNotificationRequest()
14246 
            _elem277.read(iprot)
14247 
            self.success.append(_elem277)
5944 mandeep.dh 14248 
          iprot.readListEnd()
14249 
        else:
14250 
          iprot.skip(ftype)
14251 
      else:
14252 
        iprot.skip(ftype)
14253 
      iprot.readFieldEnd()
14254 
    iprot.readStructEnd()
14255 
 
14256 
  def write(self, oprot):
14257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14259 
      return
14260 
    oprot.writeStructBegin('getProductNotifications_result')
14261 
    if self.success is not None:
14262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14263 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14264 
      for iter278 in self.success:
14265 
        iter278.write(oprot)
5944 mandeep.dh 14266 
      oprot.writeListEnd()
14267 
      oprot.writeFieldEnd()
14268 
    oprot.writeFieldStop()
14269 
    oprot.writeStructEnd()
14270 
 
14271 
  def validate(self):
14272 
    return
14273 
 
14274 
 
14275 
  def __repr__(self):
14276 
    L = ['%s=%r' % (key, value)
14277 
      for key, value in self.__dict__.iteritems()]
14278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14279 
 
14280 
  def __eq__(self, other):
14281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14282 
 
14283 
  def __ne__(self, other):
14284 
    return not (self == other)
14285 
 
14286 
class getProductNotificationRequestCount_args:
14287 
  """
14288 
  Attributes:
14289 
   - startDateTime
7897 amar.kumar 14290 
   - categoryId
5944 mandeep.dh 14291 
  """
14292 
 
14293 
  thrift_spec = (
14294 
    None, # 0
14295 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 14296 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 14297 
  )
14298 
 
7897 amar.kumar 14299 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 14300 
    self.startDateTime = startDateTime
7897 amar.kumar 14301 
    self.categoryId = categoryId
5944 mandeep.dh 14302 
 
14303 
  def read(self, iprot):
14304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14306 
      return
14307 
    iprot.readStructBegin()
14308 
    while True:
14309 
      (fname, ftype, fid) = iprot.readFieldBegin()
14310 
      if ftype == TType.STOP:
14311 
        break
14312 
      if fid == 1:
14313 
        if ftype == TType.I64:
14314 
          self.startDateTime = iprot.readI64();
14315 
        else:
14316 
          iprot.skip(ftype)
7897 amar.kumar 14317 
      elif fid == 2:
14318 
        if ftype == TType.I64:
14319 
          self.categoryId = iprot.readI64();
14320 
        else:
14321 
          iprot.skip(ftype)
5944 mandeep.dh 14322 
      else:
14323 
        iprot.skip(ftype)
14324 
      iprot.readFieldEnd()
14325 
    iprot.readStructEnd()
14326 
 
14327 
  def write(self, oprot):
14328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14330 
      return
14331 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14332 
    if self.startDateTime is not None:
14333 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14334 
      oprot.writeI64(self.startDateTime)
14335 
      oprot.writeFieldEnd()
7897 amar.kumar 14336 
    if self.categoryId is not None:
14337 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
14338 
      oprot.writeI64(self.categoryId)
14339 
      oprot.writeFieldEnd()
5944 mandeep.dh 14340 
    oprot.writeFieldStop()
14341 
    oprot.writeStructEnd()
14342 
 
14343 
  def validate(self):
14344 
    return
14345 
 
14346 
 
14347 
  def __repr__(self):
14348 
    L = ['%s=%r' % (key, value)
14349 
      for key, value in self.__dict__.iteritems()]
14350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14351 
 
14352 
  def __eq__(self, other):
14353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14354 
 
14355 
  def __ne__(self, other):
14356 
    return not (self == other)
14357 
 
14358 
class getProductNotificationRequestCount_result:
14359 
  """
14360 
  Attributes:
14361 
   - success
14362 
  """
14363 
 
14364 
  thrift_spec = (
14365 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14366 
  )
14367 
 
14368 
  def __init__(self, success=None,):
14369 
    self.success = success
14370 
 
14371 
  def read(self, iprot):
14372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14374 
      return
14375 
    iprot.readStructBegin()
14376 
    while True:
14377 
      (fname, ftype, fid) = iprot.readFieldBegin()
14378 
      if ftype == TType.STOP:
14379 
        break
14380 
      if fid == 0:
14381 
        if ftype == TType.LIST:
14382 
          self.success = []
7438 amit.gupta 14383 
          (_etype282, _size279) = iprot.readListBegin()
14384 
          for _i283 in xrange(_size279):
14385 
            _elem284 = ProductNotificationRequestCount()
14386 
            _elem284.read(iprot)
14387 
            self.success.append(_elem284)
5944 mandeep.dh 14388 
          iprot.readListEnd()
14389 
        else:
14390 
          iprot.skip(ftype)
14391 
      else:
14392 
        iprot.skip(ftype)
14393 
      iprot.readFieldEnd()
14394 
    iprot.readStructEnd()
14395 
 
14396 
  def write(self, oprot):
14397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14399 
      return
14400 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14401 
    if self.success is not None:
14402 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14403 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14404 
      for iter285 in self.success:
14405 
        iter285.write(oprot)
5944 mandeep.dh 14406 
      oprot.writeListEnd()
14407 
      oprot.writeFieldEnd()
14408 
    oprot.writeFieldStop()
14409 
    oprot.writeStructEnd()
14410 
 
14411 
  def validate(self):
14412 
    return
14413 
 
14414 
 
14415 
  def __repr__(self):
14416 
    L = ['%s=%r' % (key, value)
14417 
      for key, value in self.__dict__.iteritems()]
14418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14419 
 
14420 
  def __eq__(self, other):
14421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14422 
 
14423 
  def __ne__(self, other):
14424 
    return not (self == other)
14425 
 
14426 
class addAuthorizationLog_args:
14427 
  """
14428 
  Attributes:
14429 
   - itemId
14430 
   - username
14431 
   - reason
14432 
  """
14433 
 
14434 
  thrift_spec = (
14435 
    None, # 0
14436 
    (1, TType.I64, 'itemId', None, None, ), # 1
14437 
    (2, TType.STRING, 'username', None, None, ), # 2
14438 
    (3, TType.STRING, 'reason', None, None, ), # 3
14439 
  )
14440 
 
14441 
  def __init__(self, itemId=None, username=None, reason=None,):
14442 
    self.itemId = itemId
14443 
    self.username = username
14444 
    self.reason = reason
14445 
 
14446 
  def read(self, iprot):
14447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14449 
      return
14450 
    iprot.readStructBegin()
14451 
    while True:
14452 
      (fname, ftype, fid) = iprot.readFieldBegin()
14453 
      if ftype == TType.STOP:
14454 
        break
14455 
      if fid == 1:
14456 
        if ftype == TType.I64:
14457 
          self.itemId = iprot.readI64();
14458 
        else:
14459 
          iprot.skip(ftype)
14460 
      elif fid == 2:
14461 
        if ftype == TType.STRING:
14462 
          self.username = iprot.readString();
14463 
        else:
14464 
          iprot.skip(ftype)
14465 
      elif fid == 3:
14466 
        if ftype == TType.STRING:
14467 
          self.reason = iprot.readString();
14468 
        else:
14469 
          iprot.skip(ftype)
14470 
      else:
14471 
        iprot.skip(ftype)
14472 
      iprot.readFieldEnd()
14473 
    iprot.readStructEnd()
14474 
 
14475 
  def write(self, oprot):
14476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14478 
      return
14479 
    oprot.writeStructBegin('addAuthorizationLog_args')
14480 
    if self.itemId is not None:
14481 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14482 
      oprot.writeI64(self.itemId)
14483 
      oprot.writeFieldEnd()
14484 
    if self.username is not None:
14485 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14486 
      oprot.writeString(self.username)
14487 
      oprot.writeFieldEnd()
14488 
    if self.reason is not None:
14489 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14490 
      oprot.writeString(self.reason)
14491 
      oprot.writeFieldEnd()
14492 
    oprot.writeFieldStop()
14493 
    oprot.writeStructEnd()
14494 
 
14495 
  def validate(self):
14496 
    return
14497 
 
14498 
 
14499 
  def __repr__(self):
14500 
    L = ['%s=%r' % (key, value)
14501 
      for key, value in self.__dict__.iteritems()]
14502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14503 
 
14504 
  def __eq__(self, other):
14505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14506 
 
14507 
  def __ne__(self, other):
14508 
    return not (self == other)
14509 
 
14510 
class addAuthorizationLog_result:
14511 
  """
14512 
  Attributes:
14513 
   - success
14514 
   - cex
14515 
  """
14516 
 
14517 
  thrift_spec = (
14518 
    (0, TType.BOOL, 'success', None, None, ), # 0
14519 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14520 
  )
14521 
 
14522 
  def __init__(self, success=None, cex=None,):
14523 
    self.success = success
14524 
    self.cex = cex
14525 
 
14526 
  def read(self, iprot):
14527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14529 
      return
14530 
    iprot.readStructBegin()
14531 
    while True:
14532 
      (fname, ftype, fid) = iprot.readFieldBegin()
14533 
      if ftype == TType.STOP:
14534 
        break
14535 
      if fid == 0:
14536 
        if ftype == TType.BOOL:
14537 
          self.success = iprot.readBool();
14538 
        else:
14539 
          iprot.skip(ftype)
14540 
      elif fid == 1:
14541 
        if ftype == TType.STRUCT:
14542 
          self.cex = CatalogServiceException()
14543 
          self.cex.read(iprot)
14544 
        else:
14545 
          iprot.skip(ftype)
14546 
      else:
14547 
        iprot.skip(ftype)
14548 
      iprot.readFieldEnd()
14549 
    iprot.readStructEnd()
14550 
 
14551 
  def write(self, oprot):
14552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14554 
      return
14555 
    oprot.writeStructBegin('addAuthorizationLog_result')
14556 
    if self.success is not None:
14557 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14558 
      oprot.writeBool(self.success)
14559 
      oprot.writeFieldEnd()
14560 
    if self.cex is not None:
14561 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14562 
      self.cex.write(oprot)
14563 
      oprot.writeFieldEnd()
14564 
    oprot.writeFieldStop()
14565 
    oprot.writeStructEnd()
14566 
 
14567 
  def validate(self):
14568 
    return
14569 
 
14570 
 
14571 
  def __repr__(self):
14572 
    L = ['%s=%r' % (key, value)
14573 
      for key, value in self.__dict__.iteritems()]
14574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14575 
 
14576 
  def __eq__(self, other):
14577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14578 
 
14579 
  def __ne__(self, other):
14580 
    return not (self == other)
14581 
 
14582 
class addupdateVoucherForItem_args:
14583 
  """
14584 
  Attributes:
14585 
   - catalog_item_id
14586 
   - voucherType
14587 
   - voucherAmount
14588 
  """
14589 
 
14590 
  thrift_spec = (
14591 
    None, # 0
14592 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14593 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14594 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14595 
  )
14596 
 
14597 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14598 
    self.catalog_item_id = catalog_item_id
14599 
    self.voucherType = voucherType
14600 
    self.voucherAmount = voucherAmount
14601 
 
14602 
  def read(self, iprot):
14603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14605 
      return
14606 
    iprot.readStructBegin()
14607 
    while True:
14608 
      (fname, ftype, fid) = iprot.readFieldBegin()
14609 
      if ftype == TType.STOP:
14610 
        break
14611 
      if fid == 1:
14612 
        if ftype == TType.I64:
14613 
          self.catalog_item_id = iprot.readI64();
14614 
        else:
14615 
          iprot.skip(ftype)
14616 
      elif fid == 2:
14617 
        if ftype == TType.I64:
14618 
          self.voucherType = iprot.readI64();
14619 
        else:
14620 
          iprot.skip(ftype)
14621 
      elif fid == 3:
14622 
        if ftype == TType.I64:
14623 
          self.voucherAmount = iprot.readI64();
14624 
        else:
14625 
          iprot.skip(ftype)
14626 
      else:
14627 
        iprot.skip(ftype)
14628 
      iprot.readFieldEnd()
14629 
    iprot.readStructEnd()
14630 
 
14631 
  def write(self, oprot):
14632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14634 
      return
14635 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14636 
    if self.catalog_item_id is not None:
14637 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14638 
      oprot.writeI64(self.catalog_item_id)
14639 
      oprot.writeFieldEnd()
14640 
    if self.voucherType is not None:
14641 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14642 
      oprot.writeI64(self.voucherType)
14643 
      oprot.writeFieldEnd()
14644 
    if self.voucherAmount is not None:
14645 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14646 
      oprot.writeI64(self.voucherAmount)
14647 
      oprot.writeFieldEnd()
14648 
    oprot.writeFieldStop()
14649 
    oprot.writeStructEnd()
14650 
 
14651 
  def validate(self):
14652 
    return
14653 
 
14654 
 
14655 
  def __repr__(self):
14656 
    L = ['%s=%r' % (key, value)
14657 
      for key, value in self.__dict__.iteritems()]
14658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14659 
 
14660 
  def __eq__(self, other):
14661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14662 
 
14663 
  def __ne__(self, other):
14664 
    return not (self == other)
14665 
 
14666 
class addupdateVoucherForItem_result:
14667 
  """
14668 
  Attributes:
14669 
   - success
14670 
   - cex
14671 
  """
14672 
 
14673 
  thrift_spec = (
14674 
    (0, TType.BOOL, 'success', None, None, ), # 0
14675 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14676 
  )
14677 
 
14678 
  def __init__(self, success=None, cex=None,):
14679 
    self.success = success
14680 
    self.cex = cex
14681 
 
14682 
  def read(self, iprot):
14683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14685 
      return
14686 
    iprot.readStructBegin()
14687 
    while True:
14688 
      (fname, ftype, fid) = iprot.readFieldBegin()
14689 
      if ftype == TType.STOP:
14690 
        break
14691 
      if fid == 0:
14692 
        if ftype == TType.BOOL:
14693 
          self.success = iprot.readBool();
14694 
        else:
14695 
          iprot.skip(ftype)
14696 
      elif fid == 1:
14697 
        if ftype == TType.STRUCT:
14698 
          self.cex = CatalogServiceException()
14699 
          self.cex.read(iprot)
14700 
        else:
14701 
          iprot.skip(ftype)
14702 
      else:
14703 
        iprot.skip(ftype)
14704 
      iprot.readFieldEnd()
14705 
    iprot.readStructEnd()
14706 
 
14707 
  def write(self, oprot):
14708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14710 
      return
14711 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14712 
    if self.success is not None:
14713 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14714 
      oprot.writeBool(self.success)
14715 
      oprot.writeFieldEnd()
14716 
    if self.cex is not None:
14717 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14718 
      self.cex.write(oprot)
14719 
      oprot.writeFieldEnd()
14720 
    oprot.writeFieldStop()
14721 
    oprot.writeStructEnd()
14722 
 
14723 
  def validate(self):
14724 
    return
14725 
 
14726 
 
14727 
  def __repr__(self):
14728 
    L = ['%s=%r' % (key, value)
14729 
      for key, value in self.__dict__.iteritems()]
14730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14731 
 
14732 
  def __eq__(self, other):
14733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14734 
 
14735 
  def __ne__(self, other):
14736 
    return not (self == other)
14737 
 
14738 
class deleteVoucherForItem_args:
14739 
  """
14740 
  Attributes:
14741 
   - catalog_item_id
14742 
   - voucherType
14743 
  """
14744 
 
14745 
  thrift_spec = (
14746 
    None, # 0
14747 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14748 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14749 
  )
14750 
 
14751 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14752 
    self.catalog_item_id = catalog_item_id
14753 
    self.voucherType = voucherType
14754 
 
14755 
  def read(self, iprot):
14756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14758 
      return
14759 
    iprot.readStructBegin()
14760 
    while True:
14761 
      (fname, ftype, fid) = iprot.readFieldBegin()
14762 
      if ftype == TType.STOP:
14763 
        break
14764 
      if fid == 1:
14765 
        if ftype == TType.I64:
14766 
          self.catalog_item_id = iprot.readI64();
14767 
        else:
14768 
          iprot.skip(ftype)
14769 
      elif fid == 2:
14770 
        if ftype == TType.I64:
14771 
          self.voucherType = iprot.readI64();
14772 
        else:
14773 
          iprot.skip(ftype)
14774 
      else:
14775 
        iprot.skip(ftype)
14776 
      iprot.readFieldEnd()
14777 
    iprot.readStructEnd()
14778 
 
14779 
  def write(self, oprot):
14780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14782 
      return
14783 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14784 
    if self.catalog_item_id is not None:
14785 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14786 
      oprot.writeI64(self.catalog_item_id)
14787 
      oprot.writeFieldEnd()
14788 
    if self.voucherType is not None:
14789 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14790 
      oprot.writeI64(self.voucherType)
14791 
      oprot.writeFieldEnd()
14792 
    oprot.writeFieldStop()
14793 
    oprot.writeStructEnd()
14794 
 
14795 
  def validate(self):
14796 
    return
14797 
 
14798 
 
14799 
  def __repr__(self):
14800 
    L = ['%s=%r' % (key, value)
14801 
      for key, value in self.__dict__.iteritems()]
14802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14803 
 
14804 
  def __eq__(self, other):
14805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14806 
 
14807 
  def __ne__(self, other):
14808 
    return not (self == other)
14809 
 
14810 
class deleteVoucherForItem_result:
14811 
  """
14812 
  Attributes:
14813 
   - success
14814 
   - cex
14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    (0, TType.BOOL, 'success', None, None, ), # 0
14819 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14820 
  )
14821 
 
14822 
  def __init__(self, success=None, cex=None,):
14823 
    self.success = success
14824 
    self.cex = cex
14825 
 
14826 
  def read(self, iprot):
14827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14829 
      return
14830 
    iprot.readStructBegin()
14831 
    while True:
14832 
      (fname, ftype, fid) = iprot.readFieldBegin()
14833 
      if ftype == TType.STOP:
14834 
        break
14835 
      if fid == 0:
14836 
        if ftype == TType.BOOL:
14837 
          self.success = iprot.readBool();
14838 
        else:
14839 
          iprot.skip(ftype)
14840 
      elif fid == 1:
14841 
        if ftype == TType.STRUCT:
14842 
          self.cex = CatalogServiceException()
14843 
          self.cex.read(iprot)
14844 
        else:
14845 
          iprot.skip(ftype)
14846 
      else:
14847 
        iprot.skip(ftype)
14848 
      iprot.readFieldEnd()
14849 
    iprot.readStructEnd()
14850 
 
14851 
  def write(self, oprot):
14852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14854 
      return
14855 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14856 
    if self.success is not None:
14857 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14858 
      oprot.writeBool(self.success)
14859 
      oprot.writeFieldEnd()
14860 
    if self.cex is not None:
14861 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14862 
      self.cex.write(oprot)
14863 
      oprot.writeFieldEnd()
14864 
    oprot.writeFieldStop()
14865 
    oprot.writeStructEnd()
14866 
 
14867 
  def validate(self):
14868 
    return
14869 
 
14870 
 
14871 
  def __repr__(self):
14872 
    L = ['%s=%r' % (key, value)
14873 
      for key, value in self.__dict__.iteritems()]
14874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14875 
 
14876 
  def __eq__(self, other):
14877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14878 
 
14879 
  def __ne__(self, other):
14880 
    return not (self == other)
14881 
 
14882 
class getVoucherAmount_args:
14883 
  """
14884 
  Attributes:
14885 
   - itemId
14886 
   - voucherType
14887 
  """
14888 
 
14889 
  thrift_spec = (
14890 
    None, # 0
14891 
    (1, TType.I64, 'itemId', None, None, ), # 1
14892 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14893 
  )
14894 
 
14895 
  def __init__(self, itemId=None, voucherType=None,):
14896 
    self.itemId = itemId
14897 
    self.voucherType = voucherType
14898 
 
14899 
  def read(self, iprot):
14900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14902 
      return
14903 
    iprot.readStructBegin()
14904 
    while True:
14905 
      (fname, ftype, fid) = iprot.readFieldBegin()
14906 
      if ftype == TType.STOP:
14907 
        break
14908 
      if fid == 1:
14909 
        if ftype == TType.I64:
14910 
          self.itemId = iprot.readI64();
14911 
        else:
14912 
          iprot.skip(ftype)
14913 
      elif fid == 2:
14914 
        if ftype == TType.I64:
14915 
          self.voucherType = iprot.readI64();
14916 
        else:
14917 
          iprot.skip(ftype)
14918 
      else:
14919 
        iprot.skip(ftype)
14920 
      iprot.readFieldEnd()
14921 
    iprot.readStructEnd()
14922 
 
14923 
  def write(self, oprot):
14924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14926 
      return
14927 
    oprot.writeStructBegin('getVoucherAmount_args')
14928 
    if self.itemId is not None:
14929 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14930 
      oprot.writeI64(self.itemId)
14931 
      oprot.writeFieldEnd()
14932 
    if self.voucherType is not None:
14933 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14934 
      oprot.writeI64(self.voucherType)
14935 
      oprot.writeFieldEnd()
14936 
    oprot.writeFieldStop()
14937 
    oprot.writeStructEnd()
14938 
 
14939 
  def validate(self):
14940 
    return
14941 
 
14942 
 
14943 
  def __repr__(self):
14944 
    L = ['%s=%r' % (key, value)
14945 
      for key, value in self.__dict__.iteritems()]
14946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14947 
 
14948 
  def __eq__(self, other):
14949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14950 
 
14951 
  def __ne__(self, other):
14952 
    return not (self == other)
14953 
 
14954 
class getVoucherAmount_result:
14955 
  """
14956 
  Attributes:
14957 
   - success
14958 
  """
14959 
 
14960 
  thrift_spec = (
14961 
    (0, TType.I64, 'success', None, None, ), # 0
14962 
  )
14963 
 
14964 
  def __init__(self, success=None,):
14965 
    self.success = success
14966 
 
14967 
  def read(self, iprot):
14968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14970 
      return
14971 
    iprot.readStructBegin()
14972 
    while True:
14973 
      (fname, ftype, fid) = iprot.readFieldBegin()
14974 
      if ftype == TType.STOP:
14975 
        break
14976 
      if fid == 0:
14977 
        if ftype == TType.I64:
14978 
          self.success = iprot.readI64();
14979 
        else:
14980 
          iprot.skip(ftype)
14981 
      else:
14982 
        iprot.skip(ftype)
14983 
      iprot.readFieldEnd()
14984 
    iprot.readStructEnd()
14985 
 
14986 
  def write(self, oprot):
14987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14989 
      return
14990 
    oprot.writeStructBegin('getVoucherAmount_result')
14991 
    if self.success is not None:
14992 
      oprot.writeFieldBegin('success', TType.I64, 0)
14993 
      oprot.writeI64(self.success)
14994 
      oprot.writeFieldEnd()
14995 
    oprot.writeFieldStop()
14996 
    oprot.writeStructEnd()
14997 
 
14998 
  def validate(self):
14999 
    return
15000 
 
15001 
 
15002 
  def __repr__(self):
15003 
    L = ['%s=%r' % (key, value)
15004 
      for key, value in self.__dict__.iteritems()]
15005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15006 
 
15007 
  def __eq__(self, other):
15008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15009 
 
15010 
  def __ne__(self, other):
15011 
    return not (self == other)
15012 
 
15013 
class getAllItemVouchers_args:
15014 
  """
15015 
  Attributes:
15016 
   - itemId
15017 
  """
15018 
 
15019 
  thrift_spec = (
15020 
    None, # 0
15021 
    (1, TType.I64, 'itemId', None, None, ), # 1
15022 
  )
15023 
 
15024 
  def __init__(self, itemId=None,):
15025 
    self.itemId = itemId
15026 
 
15027 
  def read(self, iprot):
15028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15030 
      return
15031 
    iprot.readStructBegin()
15032 
    while True:
15033 
      (fname, ftype, fid) = iprot.readFieldBegin()
15034 
      if ftype == TType.STOP:
15035 
        break
15036 
      if fid == 1:
15037 
        if ftype == TType.I64:
15038 
          self.itemId = iprot.readI64();
15039 
        else:
15040 
          iprot.skip(ftype)
15041 
      else:
15042 
        iprot.skip(ftype)
15043 
      iprot.readFieldEnd()
15044 
    iprot.readStructEnd()
15045 
 
15046 
  def write(self, oprot):
15047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15049 
      return
15050 
    oprot.writeStructBegin('getAllItemVouchers_args')
15051 
    if self.itemId is not None:
15052 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15053 
      oprot.writeI64(self.itemId)
15054 
      oprot.writeFieldEnd()
15055 
    oprot.writeFieldStop()
15056 
    oprot.writeStructEnd()
15057 
 
15058 
  def validate(self):
15059 
    return
15060 
 
15061 
 
15062 
  def __repr__(self):
15063 
    L = ['%s=%r' % (key, value)
15064 
      for key, value in self.__dict__.iteritems()]
15065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15066 
 
15067 
  def __eq__(self, other):
15068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15069 
 
15070 
  def __ne__(self, other):
15071 
    return not (self == other)
15072 
 
15073 
class getAllItemVouchers_result:
15074 
  """
15075 
  Attributes:
15076 
   - success
15077 
  """
15078 
 
15079 
  thrift_spec = (
15080 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15081 
  )
15082 
 
15083 
  def __init__(self, success=None,):
15084 
    self.success = success
15085 
 
15086 
  def read(self, iprot):
15087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15089 
      return
15090 
    iprot.readStructBegin()
15091 
    while True:
15092 
      (fname, ftype, fid) = iprot.readFieldBegin()
15093 
      if ftype == TType.STOP:
15094 
        break
15095 
      if fid == 0:
15096 
        if ftype == TType.LIST:
15097 
          self.success = []
7438 amit.gupta 15098 
          (_etype289, _size286) = iprot.readListBegin()
15099 
          for _i290 in xrange(_size286):
15100 
            _elem291 = VoucherItemMapping()
15101 
            _elem291.read(iprot)
15102 
            self.success.append(_elem291)
5944 mandeep.dh 15103 
          iprot.readListEnd()
15104 
        else:
15105 
          iprot.skip(ftype)
15106 
      else:
15107 
        iprot.skip(ftype)
15108 
      iprot.readFieldEnd()
15109 
    iprot.readStructEnd()
15110 
 
15111 
  def write(self, oprot):
15112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15114 
      return
15115 
    oprot.writeStructBegin('getAllItemVouchers_result')
15116 
    if self.success is not None:
15117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15119 
      for iter292 in self.success:
15120 
        iter292.write(oprot)
5944 mandeep.dh 15121 
      oprot.writeListEnd()
15122 
      oprot.writeFieldEnd()
15123 
    oprot.writeFieldStop()
15124 
    oprot.writeStructEnd()
15125 
 
15126 
  def validate(self):
15127 
    return
15128 
 
15129 
 
15130 
  def __repr__(self):
15131 
    L = ['%s=%r' % (key, value)
15132 
      for key, value in self.__dict__.iteritems()]
15133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15134 
 
15135 
  def __eq__(self, other):
15136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15137 
 
15138 
  def __ne__(self, other):
15139 
    return not (self == other)
15140 
 
15141 
class isValidCatalogItemId_args:
15142 
  """
15143 
  Attributes:
15144 
   - catalog_item_id
15145 
  """
15146 
 
15147 
  thrift_spec = (
15148 
    None, # 0
15149 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15150 
  )
15151 
 
15152 
  def __init__(self, catalog_item_id=None,):
15153 
    self.catalog_item_id = catalog_item_id
15154 
 
15155 
  def read(self, iprot):
15156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15158 
      return
15159 
    iprot.readStructBegin()
15160 
    while True:
15161 
      (fname, ftype, fid) = iprot.readFieldBegin()
15162 
      if ftype == TType.STOP:
15163 
        break
15164 
      if fid == 1:
15165 
        if ftype == TType.I64:
15166 
          self.catalog_item_id = iprot.readI64();
15167 
        else:
15168 
          iprot.skip(ftype)
15169 
      else:
15170 
        iprot.skip(ftype)
15171 
      iprot.readFieldEnd()
15172 
    iprot.readStructEnd()
15173 
 
15174 
  def write(self, oprot):
15175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15177 
      return
15178 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15179 
    if self.catalog_item_id is not None:
15180 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15181 
      oprot.writeI64(self.catalog_item_id)
15182 
      oprot.writeFieldEnd()
15183 
    oprot.writeFieldStop()
15184 
    oprot.writeStructEnd()
15185 
 
15186 
  def validate(self):
15187 
    return
15188 
 
15189 
 
15190 
  def __repr__(self):
15191 
    L = ['%s=%r' % (key, value)
15192 
      for key, value in self.__dict__.iteritems()]
15193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15194 
 
15195 
  def __eq__(self, other):
15196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15197 
 
15198 
  def __ne__(self, other):
15199 
    return not (self == other)
15200 
 
15201 
class isValidCatalogItemId_result:
15202 
  """
15203 
  Attributes:
15204 
   - success
15205 
  """
15206 
 
15207 
  thrift_spec = (
15208 
    (0, TType.BOOL, 'success', None, None, ), # 0
15209 
  )
15210 
 
15211 
  def __init__(self, success=None,):
15212 
    self.success = success
15213 
 
15214 
  def read(self, iprot):
15215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15217 
      return
15218 
    iprot.readStructBegin()
15219 
    while True:
15220 
      (fname, ftype, fid) = iprot.readFieldBegin()
15221 
      if ftype == TType.STOP:
15222 
        break
15223 
      if fid == 0:
15224 
        if ftype == TType.BOOL:
15225 
          self.success = iprot.readBool();
15226 
        else:
15227 
          iprot.skip(ftype)
15228 
      else:
15229 
        iprot.skip(ftype)
15230 
      iprot.readFieldEnd()
15231 
    iprot.readStructEnd()
15232 
 
15233 
  def write(self, oprot):
15234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15236 
      return
15237 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15238 
    if self.success is not None:
15239 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15240 
      oprot.writeBool(self.success)
15241 
      oprot.writeFieldEnd()
15242 
    oprot.writeFieldStop()
15243 
    oprot.writeStructEnd()
15244 
 
15245 
  def validate(self):
15246 
    return
15247 
 
15248 
 
15249 
  def __repr__(self):
15250 
    L = ['%s=%r' % (key, value)
15251 
      for key, value in self.__dict__.iteritems()]
15252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15253 
 
15254 
  def __eq__(self, other):
15255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15256 
 
15257 
  def __ne__(self, other):
15258 
    return not (self == other)
6039 amit.gupta 15259 
 
15260 
class getVatPercentageForItem_args:
15261 
  """
15262 
  Attributes:
15263 
   - itemId
7330 amit.gupta 15264 
   - stateId
6039 amit.gupta 15265 
   - price
15266 
  """
15267 
 
15268 
  thrift_spec = (
15269 
    None, # 0
15270 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15271 
    (2, TType.I64, 'stateId', None, None, ), # 2
15272 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15273 
  )
15274 
 
7330 amit.gupta 15275 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15276 
    self.itemId = itemId
7330 amit.gupta 15277 
    self.stateId = stateId
6039 amit.gupta 15278 
    self.price = price
15279 
 
15280 
  def read(self, iprot):
15281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15283 
      return
15284 
    iprot.readStructBegin()
15285 
    while True:
15286 
      (fname, ftype, fid) = iprot.readFieldBegin()
15287 
      if ftype == TType.STOP:
15288 
        break
15289 
      if fid == 1:
15290 
        if ftype == TType.I64:
15291 
          self.itemId = iprot.readI64();
15292 
        else:
15293 
          iprot.skip(ftype)
15294 
      elif fid == 2:
7330 amit.gupta 15295 
        if ftype == TType.I64:
15296 
          self.stateId = iprot.readI64();
15297 
        else:
15298 
          iprot.skip(ftype)
15299 
      elif fid == 3:
6039 amit.gupta 15300 
        if ftype == TType.DOUBLE:
15301 
          self.price = iprot.readDouble();
15302 
        else:
15303 
          iprot.skip(ftype)
15304 
      else:
15305 
        iprot.skip(ftype)
15306 
      iprot.readFieldEnd()
15307 
    iprot.readStructEnd()
15308 
 
15309 
  def write(self, oprot):
15310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15312 
      return
15313 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15314 
    if self.itemId is not None:
15315 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15316 
      oprot.writeI64(self.itemId)
15317 
      oprot.writeFieldEnd()
7330 amit.gupta 15318 
    if self.stateId is not None:
15319 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15320 
      oprot.writeI64(self.stateId)
15321 
      oprot.writeFieldEnd()
6039 amit.gupta 15322 
    if self.price is not None:
7330 amit.gupta 15323 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15324 
      oprot.writeDouble(self.price)
15325 
      oprot.writeFieldEnd()
15326 
    oprot.writeFieldStop()
15327 
    oprot.writeStructEnd()
15328 
 
15329 
  def validate(self):
15330 
    return
15331 
 
15332 
 
15333 
  def __repr__(self):
15334 
    L = ['%s=%r' % (key, value)
15335 
      for key, value in self.__dict__.iteritems()]
15336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15337 
 
15338 
  def __eq__(self, other):
15339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15340 
 
15341 
  def __ne__(self, other):
15342 
    return not (self == other)
15343 
 
15344 
class getVatPercentageForItem_result:
15345 
  """
15346 
  Attributes:
15347 
   - success
7340 amit.gupta 15348 
   - cex
6039 amit.gupta 15349 
  """
15350 
 
15351 
  thrift_spec = (
15352 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15353 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15354 
  )
15355 
 
7340 amit.gupta 15356 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15357 
    self.success = success
7340 amit.gupta 15358 
    self.cex = cex
6039 amit.gupta 15359 
 
15360 
  def read(self, iprot):
15361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15363 
      return
15364 
    iprot.readStructBegin()
15365 
    while True:
15366 
      (fname, ftype, fid) = iprot.readFieldBegin()
15367 
      if ftype == TType.STOP:
15368 
        break
15369 
      if fid == 0:
15370 
        if ftype == TType.DOUBLE:
15371 
          self.success = iprot.readDouble();
15372 
        else:
15373 
          iprot.skip(ftype)
7340 amit.gupta 15374 
      elif fid == 1:
15375 
        if ftype == TType.STRUCT:
15376 
          self.cex = CatalogServiceException()
15377 
          self.cex.read(iprot)
15378 
        else:
15379 
          iprot.skip(ftype)
6039 amit.gupta 15380 
      else:
15381 
        iprot.skip(ftype)
15382 
      iprot.readFieldEnd()
15383 
    iprot.readStructEnd()
15384 
 
15385 
  def write(self, oprot):
15386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15388 
      return
15389 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15390 
    if self.success is not None:
15391 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15392 
      oprot.writeDouble(self.success)
15393 
      oprot.writeFieldEnd()
7340 amit.gupta 15394 
    if self.cex is not None:
15395 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15396 
      self.cex.write(oprot)
15397 
      oprot.writeFieldEnd()
6039 amit.gupta 15398 
    oprot.writeFieldStop()
15399 
    oprot.writeStructEnd()
15400 
 
15401 
  def validate(self):
15402 
    return
15403 
 
15404 
 
15405 
  def __repr__(self):
15406 
    L = ['%s=%r' % (key, value)
15407 
      for key, value in self.__dict__.iteritems()]
15408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15409 
 
15410 
  def __eq__(self, other):
15411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15412 
 
15413 
  def __ne__(self, other):
15414 
    return not (self == other)
15415 
 
15416 
class getVatAmountForItem_args:
15417 
  """
15418 
  Attributes:
15419 
   - itemId
15420 
   - price
15421 
  """
15422 
 
15423 
  thrift_spec = (
15424 
    None, # 0
15425 
    (1, TType.I64, 'itemId', None, None, ), # 1
15426 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15427 
  )
15428 
 
15429 
  def __init__(self, itemId=None, price=None,):
15430 
    self.itemId = itemId
15431 
    self.price = price
15432 
 
15433 
  def read(self, iprot):
15434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15436 
      return
15437 
    iprot.readStructBegin()
15438 
    while True:
15439 
      (fname, ftype, fid) = iprot.readFieldBegin()
15440 
      if ftype == TType.STOP:
15441 
        break
15442 
      if fid == 1:
15443 
        if ftype == TType.I64:
15444 
          self.itemId = iprot.readI64();
15445 
        else:
15446 
          iprot.skip(ftype)
15447 
      elif fid == 2:
15448 
        if ftype == TType.DOUBLE:
15449 
          self.price = iprot.readDouble();
15450 
        else:
15451 
          iprot.skip(ftype)
15452 
      else:
15453 
        iprot.skip(ftype)
15454 
      iprot.readFieldEnd()
15455 
    iprot.readStructEnd()
15456 
 
15457 
  def write(self, oprot):
15458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15460 
      return
15461 
    oprot.writeStructBegin('getVatAmountForItem_args')
15462 
    if self.itemId is not None:
15463 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15464 
      oprot.writeI64(self.itemId)
15465 
      oprot.writeFieldEnd()
15466 
    if self.price is not None:
15467 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15468 
      oprot.writeDouble(self.price)
15469 
      oprot.writeFieldEnd()
15470 
    oprot.writeFieldStop()
15471 
    oprot.writeStructEnd()
15472 
 
15473 
  def validate(self):
15474 
    return
15475 
 
15476 
 
15477 
  def __repr__(self):
15478 
    L = ['%s=%r' % (key, value)
15479 
      for key, value in self.__dict__.iteritems()]
15480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15481 
 
15482 
  def __eq__(self, other):
15483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15484 
 
15485 
  def __ne__(self, other):
15486 
    return not (self == other)
15487 
 
15488 
class getVatAmountForItem_result:
15489 
  """
15490 
  Attributes:
15491 
   - success
15492 
  """
15493 
 
15494 
  thrift_spec = (
15495 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15496 
  )
15497 
 
15498 
  def __init__(self, success=None,):
15499 
    self.success = success
15500 
 
15501 
  def read(self, iprot):
15502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15504 
      return
15505 
    iprot.readStructBegin()
15506 
    while True:
15507 
      (fname, ftype, fid) = iprot.readFieldBegin()
15508 
      if ftype == TType.STOP:
15509 
        break
15510 
      if fid == 0:
15511 
        if ftype == TType.DOUBLE:
15512 
          self.success = iprot.readDouble();
15513 
        else:
15514 
          iprot.skip(ftype)
15515 
      else:
15516 
        iprot.skip(ftype)
15517 
      iprot.readFieldEnd()
15518 
    iprot.readStructEnd()
15519 
 
15520 
  def write(self, oprot):
15521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15523 
      return
15524 
    oprot.writeStructBegin('getVatAmountForItem_result')
15525 
    if self.success is not None:
15526 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15527 
      oprot.writeDouble(self.success)
15528 
      oprot.writeFieldEnd()
15529 
    oprot.writeFieldStop()
15530 
    oprot.writeStructEnd()
15531 
 
15532 
  def validate(self):
15533 
    return
15534 
 
15535 
 
15536 
  def __repr__(self):
15537 
    L = ['%s=%r' % (key, value)
15538 
      for key, value in self.__dict__.iteritems()]
15539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15540 
 
15541 
  def __eq__(self, other):
15542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15543 
 
15544 
  def __ne__(self, other):
15545 
    return not (self == other)
6531 vikram.rag 15546 
 
15547 
class getAllIgnoredInventoryUpdateItemsList_args:
15548 
  """
15549 
  Attributes:
15550 
   - offset
15551 
   - limit
15552 
  """
15553 
 
15554 
  thrift_spec = (
15555 
    None, # 0
15556 
    (1, TType.I32, 'offset', None, None, ), # 1
15557 
    (2, TType.I32, 'limit', None, None, ), # 2
15558 
  )
15559 
 
15560 
  def __init__(self, offset=None, limit=None,):
15561 
    self.offset = offset
15562 
    self.limit = limit
15563 
 
15564 
  def read(self, iprot):
15565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15567 
      return
15568 
    iprot.readStructBegin()
15569 
    while True:
15570 
      (fname, ftype, fid) = iprot.readFieldBegin()
15571 
      if ftype == TType.STOP:
15572 
        break
15573 
      if fid == 1:
15574 
        if ftype == TType.I32:
15575 
          self.offset = iprot.readI32();
15576 
        else:
15577 
          iprot.skip(ftype)
15578 
      elif fid == 2:
15579 
        if ftype == TType.I32:
15580 
          self.limit = iprot.readI32();
15581 
        else:
15582 
          iprot.skip(ftype)
15583 
      else:
15584 
        iprot.skip(ftype)
15585 
      iprot.readFieldEnd()
15586 
    iprot.readStructEnd()
15587 
 
15588 
  def write(self, oprot):
15589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15591 
      return
15592 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15593 
    if self.offset is not None:
15594 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15595 
      oprot.writeI32(self.offset)
15596 
      oprot.writeFieldEnd()
15597 
    if self.limit is not None:
15598 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15599 
      oprot.writeI32(self.limit)
15600 
      oprot.writeFieldEnd()
15601 
    oprot.writeFieldStop()
15602 
    oprot.writeStructEnd()
15603 
 
15604 
  def validate(self):
15605 
    return
15606 
 
15607 
 
15608 
  def __repr__(self):
15609 
    L = ['%s=%r' % (key, value)
15610 
      for key, value in self.__dict__.iteritems()]
15611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15612 
 
15613 
  def __eq__(self, other):
15614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15615 
 
15616 
  def __ne__(self, other):
15617 
    return not (self == other)
15618 
 
15619 
class getAllIgnoredInventoryUpdateItemsList_result:
15620 
  """
15621 
  Attributes:
15622 
   - success
15623 
  """
15624 
 
15625 
  thrift_spec = (
15626 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15627 
  )
15628 
 
15629 
  def __init__(self, success=None,):
15630 
    self.success = success
15631 
 
15632 
  def read(self, iprot):
15633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15635 
      return
15636 
    iprot.readStructBegin()
15637 
    while True:
15638 
      (fname, ftype, fid) = iprot.readFieldBegin()
15639 
      if ftype == TType.STOP:
15640 
        break
15641 
      if fid == 0:
15642 
        if ftype == TType.LIST:
15643 
          self.success = []
7438 amit.gupta 15644 
          (_etype296, _size293) = iprot.readListBegin()
15645 
          for _i297 in xrange(_size293):
15646 
            _elem298 = Item()
15647 
            _elem298.read(iprot)
15648 
            self.success.append(_elem298)
6531 vikram.rag 15649 
          iprot.readListEnd()
15650 
        else:
15651 
          iprot.skip(ftype)
15652 
      else:
15653 
        iprot.skip(ftype)
15654 
      iprot.readFieldEnd()
15655 
    iprot.readStructEnd()
15656 
 
15657 
  def write(self, oprot):
15658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15660 
      return
15661 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15662 
    if self.success is not None:
15663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15664 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15665 
      for iter299 in self.success:
15666 
        iter299.write(oprot)
6531 vikram.rag 15667 
      oprot.writeListEnd()
15668 
      oprot.writeFieldEnd()
15669 
    oprot.writeFieldStop()
15670 
    oprot.writeStructEnd()
15671 
 
15672 
  def validate(self):
15673 
    return
15674 
 
15675 
 
15676 
  def __repr__(self):
15677 
    L = ['%s=%r' % (key, value)
15678 
      for key, value in self.__dict__.iteritems()]
15679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15680 
 
15681 
  def __eq__(self, other):
15682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15683 
 
15684 
  def __ne__(self, other):
15685 
    return not (self == other)
6805 anupam.sin 15686 
 
6821 amar.kumar 15687 
class getAllAliveItems_args:
15688 
 
15689 
  thrift_spec = (
15690 
  )
15691 
 
15692 
  def read(self, iprot):
15693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15695 
      return
15696 
    iprot.readStructBegin()
15697 
    while True:
15698 
      (fname, ftype, fid) = iprot.readFieldBegin()
15699 
      if ftype == TType.STOP:
15700 
        break
15701 
      else:
15702 
        iprot.skip(ftype)
15703 
      iprot.readFieldEnd()
15704 
    iprot.readStructEnd()
15705 
 
15706 
  def write(self, oprot):
15707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15709 
      return
15710 
    oprot.writeStructBegin('getAllAliveItems_args')
15711 
    oprot.writeFieldStop()
15712 
    oprot.writeStructEnd()
15713 
 
15714 
  def validate(self):
15715 
    return
15716 
 
15717 
 
15718 
  def __repr__(self):
15719 
    L = ['%s=%r' % (key, value)
15720 
      for key, value in self.__dict__.iteritems()]
15721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15722 
 
15723 
  def __eq__(self, other):
15724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15725 
 
15726 
  def __ne__(self, other):
15727 
    return not (self == other)
15728 
 
15729 
class getAllAliveItems_result:
15730 
  """
15731 
  Attributes:
15732 
   - success
15733 
  """
15734 
 
15735 
  thrift_spec = (
15736 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15737 
  )
15738 
 
15739 
  def __init__(self, success=None,):
15740 
    self.success = success
15741 
 
15742 
  def read(self, iprot):
15743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15745 
      return
15746 
    iprot.readStructBegin()
15747 
    while True:
15748 
      (fname, ftype, fid) = iprot.readFieldBegin()
15749 
      if ftype == TType.STOP:
15750 
        break
15751 
      if fid == 0:
15752 
        if ftype == TType.LIST:
15753 
          self.success = []
7438 amit.gupta 15754 
          (_etype303, _size300) = iprot.readListBegin()
15755 
          for _i304 in xrange(_size300):
15756 
            _elem305 = Item()
15757 
            _elem305.read(iprot)
15758 
            self.success.append(_elem305)
6821 amar.kumar 15759 
          iprot.readListEnd()
15760 
        else:
15761 
          iprot.skip(ftype)
15762 
      else:
15763 
        iprot.skip(ftype)
15764 
      iprot.readFieldEnd()
15765 
    iprot.readStructEnd()
15766 
 
15767 
  def write(self, oprot):
15768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15770 
      return
15771 
    oprot.writeStructBegin('getAllAliveItems_result')
15772 
    if self.success is not None:
15773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15775 
      for iter306 in self.success:
15776 
        iter306.write(oprot)
6821 amar.kumar 15777 
      oprot.writeListEnd()
15778 
      oprot.writeFieldEnd()
15779 
    oprot.writeFieldStop()
15780 
    oprot.writeStructEnd()
15781 
 
15782 
  def validate(self):
15783 
    return
15784 
 
15785 
 
15786 
  def __repr__(self):
15787 
    L = ['%s=%r' % (key, value)
15788 
      for key, value in self.__dict__.iteritems()]
15789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15790 
 
15791 
  def __eq__(self, other):
15792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15793 
 
15794 
  def __ne__(self, other):
15795 
    return not (self == other)
15796 
 
6805 anupam.sin 15797 
class getInsuranceAmount_args:
15798 
  """
15799 
  Attributes:
15800 
   - itemId
6921 anupam.sin 15801 
   - price
6805 anupam.sin 15802 
   - insurerId
15803 
   - quantity
15804 
  """
15805 
 
15806 
  thrift_spec = (
15807 
    None, # 0
15808 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15809 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15810 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15811 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15812 
  )
15813 
 
6921 anupam.sin 15814 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15815 
    self.itemId = itemId
6921 anupam.sin 15816 
    self.price = price
6805 anupam.sin 15817 
    self.insurerId = insurerId
15818 
    self.quantity = quantity
15819 
 
15820 
  def read(self, iprot):
15821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15823 
      return
15824 
    iprot.readStructBegin()
15825 
    while True:
15826 
      (fname, ftype, fid) = iprot.readFieldBegin()
15827 
      if ftype == TType.STOP:
15828 
        break
15829 
      if fid == 1:
15830 
        if ftype == TType.I64:
15831 
          self.itemId = iprot.readI64();
15832 
        else:
15833 
          iprot.skip(ftype)
15834 
      elif fid == 2:
6921 anupam.sin 15835 
        if ftype == TType.DOUBLE:
15836 
          self.price = iprot.readDouble();
15837 
        else:
15838 
          iprot.skip(ftype)
15839 
      elif fid == 3:
6805 anupam.sin 15840 
        if ftype == TType.I64:
15841 
          self.insurerId = iprot.readI64();
15842 
        else:
15843 
          iprot.skip(ftype)
6921 anupam.sin 15844 
      elif fid == 4:
6805 anupam.sin 15845 
        if ftype == TType.I64:
15846 
          self.quantity = iprot.readI64();
15847 
        else:
15848 
          iprot.skip(ftype)
15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
15858 
    oprot.writeStructBegin('getInsuranceAmount_args')
15859 
    if self.itemId is not None:
15860 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15861 
      oprot.writeI64(self.itemId)
15862 
      oprot.writeFieldEnd()
6921 anupam.sin 15863 
    if self.price is not None:
15864 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15865 
      oprot.writeDouble(self.price)
15866 
      oprot.writeFieldEnd()
6805 anupam.sin 15867 
    if self.insurerId is not None:
6921 anupam.sin 15868 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15869 
      oprot.writeI64(self.insurerId)
15870 
      oprot.writeFieldEnd()
15871 
    if self.quantity is not None:
6921 anupam.sin 15872 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15873 
      oprot.writeI64(self.quantity)
15874 
      oprot.writeFieldEnd()
15875 
    oprot.writeFieldStop()
15876 
    oprot.writeStructEnd()
15877 
 
15878 
  def validate(self):
15879 
    return
15880 
 
15881 
 
15882 
  def __repr__(self):
15883 
    L = ['%s=%r' % (key, value)
15884 
      for key, value in self.__dict__.iteritems()]
15885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15886 
 
15887 
  def __eq__(self, other):
15888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15889 
 
15890 
  def __ne__(self, other):
15891 
    return not (self == other)
15892 
 
15893 
class getInsuranceAmount_result:
15894 
  """
15895 
  Attributes:
15896 
   - success
15897 
  """
15898 
 
15899 
  thrift_spec = (
15900 
    (0, TType.I64, 'success', None, None, ), # 0
15901 
  )
15902 
 
15903 
  def __init__(self, success=None,):
15904 
    self.success = success
15905 
 
15906 
  def read(self, iprot):
15907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15909 
      return
15910 
    iprot.readStructBegin()
15911 
    while True:
15912 
      (fname, ftype, fid) = iprot.readFieldBegin()
15913 
      if ftype == TType.STOP:
15914 
        break
15915 
      if fid == 0:
15916 
        if ftype == TType.I64:
15917 
          self.success = iprot.readI64();
15918 
        else:
15919 
          iprot.skip(ftype)
15920 
      else:
15921 
        iprot.skip(ftype)
15922 
      iprot.readFieldEnd()
15923 
    iprot.readStructEnd()
15924 
 
15925 
  def write(self, oprot):
15926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15928 
      return
15929 
    oprot.writeStructBegin('getInsuranceAmount_result')
15930 
    if self.success is not None:
15931 
      oprot.writeFieldBegin('success', TType.I64, 0)
15932 
      oprot.writeI64(self.success)
15933 
      oprot.writeFieldEnd()
15934 
    oprot.writeFieldStop()
15935 
    oprot.writeStructEnd()
15936 
 
15937 
  def validate(self):
15938 
    return
15939 
 
15940 
 
15941 
  def __repr__(self):
15942 
    L = ['%s=%r' % (key, value)
15943 
      for key, value in self.__dict__.iteritems()]
15944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15945 
 
15946 
  def __eq__(self, other):
15947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15948 
 
15949 
  def __ne__(self, other):
15950 
    return not (self == other)
15951 
 
15952 
class getInsurer_args:
15953 
  """
15954 
  Attributes:
15955 
   - insurerId
15956 
  """
15957 
 
15958 
  thrift_spec = (
15959 
    None, # 0
15960 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15961 
  )
15962 
 
15963 
  def __init__(self, insurerId=None,):
15964 
    self.insurerId = insurerId
15965 
 
15966 
  def read(self, iprot):
15967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15969 
      return
15970 
    iprot.readStructBegin()
15971 
    while True:
15972 
      (fname, ftype, fid) = iprot.readFieldBegin()
15973 
      if ftype == TType.STOP:
15974 
        break
15975 
      if fid == 1:
15976 
        if ftype == TType.I64:
15977 
          self.insurerId = iprot.readI64();
15978 
        else:
15979 
          iprot.skip(ftype)
15980 
      else:
15981 
        iprot.skip(ftype)
15982 
      iprot.readFieldEnd()
15983 
    iprot.readStructEnd()
15984 
 
15985 
  def write(self, oprot):
15986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15988 
      return
15989 
    oprot.writeStructBegin('getInsurer_args')
15990 
    if self.insurerId is not None:
15991 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15992 
      oprot.writeI64(self.insurerId)
15993 
      oprot.writeFieldEnd()
15994 
    oprot.writeFieldStop()
15995 
    oprot.writeStructEnd()
15996 
 
15997 
  def validate(self):
15998 
    return
15999 
 
16000 
 
16001 
  def __repr__(self):
16002 
    L = ['%s=%r' % (key, value)
16003 
      for key, value in self.__dict__.iteritems()]
16004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16005 
 
16006 
  def __eq__(self, other):
16007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16008 
 
16009 
  def __ne__(self, other):
16010 
    return not (self == other)
16011 
 
16012 
class getInsurer_result:
16013 
  """
16014 
  Attributes:
16015 
   - success
16016 
  """
16017 
 
16018 
  thrift_spec = (
16019 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
16020 
  )
16021 
 
16022 
  def __init__(self, success=None,):
16023 
    self.success = success
16024 
 
16025 
  def read(self, iprot):
16026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16028 
      return
16029 
    iprot.readStructBegin()
16030 
    while True:
16031 
      (fname, ftype, fid) = iprot.readFieldBegin()
16032 
      if ftype == TType.STOP:
16033 
        break
16034 
      if fid == 0:
16035 
        if ftype == TType.STRUCT:
16036 
          self.success = Insurer()
16037 
          self.success.read(iprot)
16038 
        else:
16039 
          iprot.skip(ftype)
16040 
      else:
16041 
        iprot.skip(ftype)
16042 
      iprot.readFieldEnd()
16043 
    iprot.readStructEnd()
16044 
 
16045 
  def write(self, oprot):
16046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16048 
      return
16049 
    oprot.writeStructBegin('getInsurer_result')
16050 
    if self.success is not None:
16051 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16052 
      self.success.write(oprot)
16053 
      oprot.writeFieldEnd()
16054 
    oprot.writeFieldStop()
16055 
    oprot.writeStructEnd()
16056 
 
16057 
  def validate(self):
16058 
    return
16059 
 
16060 
 
16061 
  def __repr__(self):
16062 
    L = ['%s=%r' % (key, value)
16063 
      for key, value in self.__dict__.iteritems()]
16064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16065 
 
16066 
  def __eq__(self, other):
16067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16068 
 
16069 
  def __ne__(self, other):
16070 
    return not (self == other)
6838 vikram.rag 16071 
 
16072 
class getAllInsurers_args:
16073 
 
16074 
  thrift_spec = (
16075 
  )
16076 
 
16077 
  def read(self, iprot):
16078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16080 
      return
16081 
    iprot.readStructBegin()
16082 
    while True:
16083 
      (fname, ftype, fid) = iprot.readFieldBegin()
16084 
      if ftype == TType.STOP:
16085 
        break
16086 
      else:
16087 
        iprot.skip(ftype)
16088 
      iprot.readFieldEnd()
16089 
    iprot.readStructEnd()
16090 
 
16091 
  def write(self, oprot):
16092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16094 
      return
16095 
    oprot.writeStructBegin('getAllInsurers_args')
16096 
    oprot.writeFieldStop()
16097 
    oprot.writeStructEnd()
16098 
 
16099 
  def validate(self):
16100 
    return
16101 
 
16102 
 
16103 
  def __repr__(self):
16104 
    L = ['%s=%r' % (key, value)
16105 
      for key, value in self.__dict__.iteritems()]
16106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16107 
 
16108 
  def __eq__(self, other):
16109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16110 
 
16111 
  def __ne__(self, other):
16112 
    return not (self == other)
16113 
 
16114 
class getAllInsurers_result:
16115 
  """
16116 
  Attributes:
16117 
   - success
16118 
  """
16119 
 
16120 
  thrift_spec = (
16121 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16122 
  )
16123 
 
16124 
  def __init__(self, success=None,):
16125 
    self.success = success
16126 
 
16127 
  def read(self, iprot):
16128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16130 
      return
16131 
    iprot.readStructBegin()
16132 
    while True:
16133 
      (fname, ftype, fid) = iprot.readFieldBegin()
16134 
      if ftype == TType.STOP:
16135 
        break
16136 
      if fid == 0:
16137 
        if ftype == TType.LIST:
16138 
          self.success = []
7438 amit.gupta 16139 
          (_etype310, _size307) = iprot.readListBegin()
16140 
          for _i311 in xrange(_size307):
16141 
            _elem312 = Insurer()
16142 
            _elem312.read(iprot)
16143 
            self.success.append(_elem312)
6838 vikram.rag 16144 
          iprot.readListEnd()
16145 
        else:
16146 
          iprot.skip(ftype)
16147 
      else:
16148 
        iprot.skip(ftype)
16149 
      iprot.readFieldEnd()
16150 
    iprot.readStructEnd()
16151 
 
16152 
  def write(self, oprot):
16153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16155 
      return
16156 
    oprot.writeStructBegin('getAllInsurers_result')
16157 
    if self.success is not None:
16158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16159 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16160 
      for iter313 in self.success:
16161 
        iter313.write(oprot)
6838 vikram.rag 16162 
      oprot.writeListEnd()
16163 
      oprot.writeFieldEnd()
16164 
    oprot.writeFieldStop()
16165 
    oprot.writeStructEnd()
16166 
 
16167 
  def validate(self):
16168 
    return
16169 
 
16170 
 
16171 
  def __repr__(self):
16172 
    L = ['%s=%r' % (key, value)
16173 
      for key, value in self.__dict__.iteritems()]
16174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16175 
 
16176 
  def __eq__(self, other):
16177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16178 
 
16179 
  def __ne__(self, other):
16180 
    return not (self == other)
6962 rajveer 16181 
 
16182 
class updateInsuranceDeclaredAmount_args:
16183 
  """
16184 
  Attributes:
16185 
   - insurerId
16186 
   - amount
16187 
  """
16188 
 
16189 
  thrift_spec = (
16190 
    None, # 0
16191 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16192 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16193 
  )
16194 
 
16195 
  def __init__(self, insurerId=None, amount=None,):
16196 
    self.insurerId = insurerId
16197 
    self.amount = amount
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 == 1:
16209 
        if ftype == TType.I64:
16210 
          self.insurerId = iprot.readI64();
16211 
        else:
16212 
          iprot.skip(ftype)
16213 
      elif fid == 2:
16214 
        if ftype == TType.DOUBLE:
16215 
          self.amount = iprot.readDouble();
16216 
        else:
16217 
          iprot.skip(ftype)
16218 
      else:
16219 
        iprot.skip(ftype)
16220 
      iprot.readFieldEnd()
16221 
    iprot.readStructEnd()
16222 
 
16223 
  def write(self, oprot):
16224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16226 
      return
16227 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16228 
    if self.insurerId is not None:
16229 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16230 
      oprot.writeI64(self.insurerId)
16231 
      oprot.writeFieldEnd()
16232 
    if self.amount is not None:
16233 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16234 
      oprot.writeDouble(self.amount)
16235 
      oprot.writeFieldEnd()
16236 
    oprot.writeFieldStop()
16237 
    oprot.writeStructEnd()
16238 
 
16239 
  def validate(self):
16240 
    return
16241 
 
16242 
 
16243 
  def __repr__(self):
16244 
    L = ['%s=%r' % (key, value)
16245 
      for key, value in self.__dict__.iteritems()]
16246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16247 
 
16248 
  def __eq__(self, other):
16249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16250 
 
16251 
  def __ne__(self, other):
16252 
    return not (self == other)
16253 
 
16254 
class updateInsuranceDeclaredAmount_result:
16255 
 
16256 
  thrift_spec = (
16257 
  )
16258 
 
16259 
  def read(self, iprot):
16260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16262 
      return
16263 
    iprot.readStructBegin()
16264 
    while True:
16265 
      (fname, ftype, fid) = iprot.readFieldBegin()
16266 
      if ftype == TType.STOP:
16267 
        break
16268 
      else:
16269 
        iprot.skip(ftype)
16270 
      iprot.readFieldEnd()
16271 
    iprot.readStructEnd()
16272 
 
16273 
  def write(self, oprot):
16274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16276 
      return
16277 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16278 
    oprot.writeFieldStop()
16279 
    oprot.writeStructEnd()
16280 
 
16281 
  def validate(self):
16282 
    return
16283 
 
16284 
 
16285 
  def __repr__(self):
16286 
    L = ['%s=%r' % (key, value)
16287 
      for key, value in self.__dict__.iteritems()]
16288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16289 
 
16290 
  def __eq__(self, other):
16291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16292 
 
16293 
  def __ne__(self, other):
16294 
    return not (self == other)
7190 amar.kumar 16295 
 
16296 
class getFreebieForItem_args:
16297 
  """
16298 
  Attributes:
16299 
   - itemId
16300 
  """
16301 
 
16302 
  thrift_spec = (
16303 
    None, # 0
16304 
    (1, TType.I64, 'itemId', None, None, ), # 1
16305 
  )
16306 
 
16307 
  def __init__(self, itemId=None,):
16308 
    self.itemId = itemId
16309 
 
16310 
  def read(self, iprot):
16311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16313 
      return
16314 
    iprot.readStructBegin()
16315 
    while True:
16316 
      (fname, ftype, fid) = iprot.readFieldBegin()
16317 
      if ftype == TType.STOP:
16318 
        break
16319 
      if fid == 1:
16320 
        if ftype == TType.I64:
16321 
          self.itemId = iprot.readI64();
16322 
        else:
16323 
          iprot.skip(ftype)
16324 
      else:
16325 
        iprot.skip(ftype)
16326 
      iprot.readFieldEnd()
16327 
    iprot.readStructEnd()
16328 
 
16329 
  def write(self, oprot):
16330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16332 
      return
16333 
    oprot.writeStructBegin('getFreebieForItem_args')
16334 
    if self.itemId is not None:
16335 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16336 
      oprot.writeI64(self.itemId)
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)
16355 
 
16356 
class getFreebieForItem_result:
16357 
  """
16358 
  Attributes:
16359 
   - success
16360 
  """
16361 
 
16362 
  thrift_spec = (
16363 
    (0, TType.I64, 'success', None, None, ), # 0
16364 
  )
16365 
 
16366 
  def __init__(self, success=None,):
16367 
    self.success = success
16368 
 
16369 
  def read(self, iprot):
16370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16372 
      return
16373 
    iprot.readStructBegin()
16374 
    while True:
16375 
      (fname, ftype, fid) = iprot.readFieldBegin()
16376 
      if ftype == TType.STOP:
16377 
        break
16378 
      if fid == 0:
16379 
        if ftype == TType.I64:
16380 
          self.success = iprot.readI64();
16381 
        else:
16382 
          iprot.skip(ftype)
16383 
      else:
16384 
        iprot.skip(ftype)
16385 
      iprot.readFieldEnd()
16386 
    iprot.readStructEnd()
16387 
 
16388 
  def write(self, oprot):
16389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16391 
      return
16392 
    oprot.writeStructBegin('getFreebieForItem_result')
16393 
    if self.success is not None:
16394 
      oprot.writeFieldBegin('success', TType.I64, 0)
16395 
      oprot.writeI64(self.success)
16396 
      oprot.writeFieldEnd()
16397 
    oprot.writeFieldStop()
16398 
    oprot.writeStructEnd()
16399 
 
16400 
  def validate(self):
16401 
    return
16402 
 
16403 
 
16404 
  def __repr__(self):
16405 
    L = ['%s=%r' % (key, value)
16406 
      for key, value in self.__dict__.iteritems()]
16407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16408 
 
16409 
  def __eq__(self, other):
16410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16411 
 
16412 
  def __ne__(self, other):
16413 
    return not (self == other)
16414 
 
16415 
class addOrUpdateFreebieForItem_args:
16416 
  """
16417 
  Attributes:
16418 
   - freebieItem
16419 
  """
16420 
 
16421 
  thrift_spec = (
16422 
    None, # 0
16423 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16424 
  )
16425 
 
16426 
  def __init__(self, freebieItem=None,):
16427 
    self.freebieItem = freebieItem
16428 
 
16429 
  def read(self, iprot):
16430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16432 
      return
16433 
    iprot.readStructBegin()
16434 
    while True:
16435 
      (fname, ftype, fid) = iprot.readFieldBegin()
16436 
      if ftype == TType.STOP:
16437 
        break
16438 
      if fid == 1:
16439 
        if ftype == TType.STRUCT:
16440 
          self.freebieItem = FreebieItem()
16441 
          self.freebieItem.read(iprot)
16442 
        else:
16443 
          iprot.skip(ftype)
16444 
      else:
16445 
        iprot.skip(ftype)
16446 
      iprot.readFieldEnd()
16447 
    iprot.readStructEnd()
16448 
 
16449 
  def write(self, oprot):
16450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16452 
      return
16453 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16454 
    if self.freebieItem is not None:
16455 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16456 
      self.freebieItem.write(oprot)
16457 
      oprot.writeFieldEnd()
16458 
    oprot.writeFieldStop()
16459 
    oprot.writeStructEnd()
16460 
 
16461 
  def validate(self):
16462 
    return
16463 
 
16464 
 
16465 
  def __repr__(self):
16466 
    L = ['%s=%r' % (key, value)
16467 
      for key, value in self.__dict__.iteritems()]
16468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16469 
 
16470 
  def __eq__(self, other):
16471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16472 
 
16473 
  def __ne__(self, other):
16474 
    return not (self == other)
16475 
 
16476 
class addOrUpdateFreebieForItem_result:
16477 
 
16478 
  thrift_spec = (
16479 
  )
16480 
 
16481 
  def read(self, iprot):
16482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16484 
      return
16485 
    iprot.readStructBegin()
16486 
    while True:
16487 
      (fname, ftype, fid) = iprot.readFieldBegin()
16488 
      if ftype == TType.STOP:
16489 
        break
16490 
      else:
16491 
        iprot.skip(ftype)
16492 
      iprot.readFieldEnd()
16493 
    iprot.readStructEnd()
16494 
 
16495 
  def write(self, oprot):
16496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16498 
      return
16499 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16500 
    oprot.writeFieldStop()
16501 
    oprot.writeStructEnd()
16502 
 
16503 
  def validate(self):
16504 
    return
16505 
 
16506 
 
16507 
  def __repr__(self):
16508 
    L = ['%s=%r' % (key, value)
16509 
      for key, value in self.__dict__.iteritems()]
16510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16511 
 
16512 
  def __eq__(self, other):
16513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16514 
 
16515 
  def __ne__(self, other):
16516 
    return not (self == other)
7256 rajveer 16517 
 
7272 amit.gupta 16518 
class addOrUpdateBrandInfo_args:
16519 
  """
16520 
  Attributes:
16521 
   - brandInfo
16522 
  """
16523 
 
16524 
  thrift_spec = (
16525 
    None, # 0
16526 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16527 
  )
16528 
 
16529 
  def __init__(self, brandInfo=None,):
16530 
    self.brandInfo = brandInfo
16531 
 
16532 
  def read(self, iprot):
16533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16535 
      return
16536 
    iprot.readStructBegin()
16537 
    while True:
16538 
      (fname, ftype, fid) = iprot.readFieldBegin()
16539 
      if ftype == TType.STOP:
16540 
        break
16541 
      if fid == 1:
16542 
        if ftype == TType.STRUCT:
16543 
          self.brandInfo = BrandInfo()
16544 
          self.brandInfo.read(iprot)
16545 
        else:
16546 
          iprot.skip(ftype)
16547 
      else:
16548 
        iprot.skip(ftype)
16549 
      iprot.readFieldEnd()
16550 
    iprot.readStructEnd()
16551 
 
16552 
  def write(self, oprot):
16553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16555 
      return
16556 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16557 
    if self.brandInfo is not None:
16558 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16559 
      self.brandInfo.write(oprot)
16560 
      oprot.writeFieldEnd()
16561 
    oprot.writeFieldStop()
16562 
    oprot.writeStructEnd()
16563 
 
16564 
  def validate(self):
16565 
    return
16566 
 
16567 
 
16568 
  def __repr__(self):
16569 
    L = ['%s=%r' % (key, value)
16570 
      for key, value in self.__dict__.iteritems()]
16571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16572 
 
16573 
  def __eq__(self, other):
16574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16575 
 
16576 
  def __ne__(self, other):
16577 
    return not (self == other)
16578 
 
16579 
class addOrUpdateBrandInfo_result:
16580 
 
16581 
  thrift_spec = (
16582 
  )
16583 
 
16584 
  def read(self, iprot):
16585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16587 
      return
16588 
    iprot.readStructBegin()
16589 
    while True:
16590 
      (fname, ftype, fid) = iprot.readFieldBegin()
16591 
      if ftype == TType.STOP:
16592 
        break
16593 
      else:
16594 
        iprot.skip(ftype)
16595 
      iprot.readFieldEnd()
16596 
    iprot.readStructEnd()
16597 
 
16598 
  def write(self, oprot):
16599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16601 
      return
16602 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16603 
    oprot.writeFieldStop()
16604 
    oprot.writeStructEnd()
16605 
 
16606 
  def validate(self):
16607 
    return
16608 
 
16609 
 
16610 
  def __repr__(self):
16611 
    L = ['%s=%r' % (key, value)
16612 
      for key, value in self.__dict__.iteritems()]
16613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16614 
 
16615 
  def __eq__(self, other):
16616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16617 
 
16618 
  def __ne__(self, other):
16619 
    return not (self == other)
16620 
 
16621 
class getBrandInfo_args:
16622 
 
16623 
  thrift_spec = (
16624 
  )
16625 
 
16626 
  def read(self, iprot):
16627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16629 
      return
16630 
    iprot.readStructBegin()
16631 
    while True:
16632 
      (fname, ftype, fid) = iprot.readFieldBegin()
16633 
      if ftype == TType.STOP:
16634 
        break
16635 
      else:
16636 
        iprot.skip(ftype)
16637 
      iprot.readFieldEnd()
16638 
    iprot.readStructEnd()
16639 
 
16640 
  def write(self, oprot):
16641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16643 
      return
16644 
    oprot.writeStructBegin('getBrandInfo_args')
16645 
    oprot.writeFieldStop()
16646 
    oprot.writeStructEnd()
16647 
 
16648 
  def validate(self):
16649 
    return
16650 
 
16651 
 
16652 
  def __repr__(self):
16653 
    L = ['%s=%r' % (key, value)
16654 
      for key, value in self.__dict__.iteritems()]
16655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16656 
 
16657 
  def __eq__(self, other):
16658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16659 
 
16660 
  def __ne__(self, other):
16661 
    return not (self == other)
16662 
 
16663 
class getBrandInfo_result:
16664 
  """
16665 
  Attributes:
16666 
   - success
16667 
  """
16668 
 
16669 
  thrift_spec = (
16670 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16671 
  )
16672 
 
16673 
  def __init__(self, success=None,):
16674 
    self.success = success
16675 
 
16676 
  def read(self, iprot):
16677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16679 
      return
16680 
    iprot.readStructBegin()
16681 
    while True:
16682 
      (fname, ftype, fid) = iprot.readFieldBegin()
16683 
      if ftype == TType.STOP:
16684 
        break
16685 
      if fid == 0:
16686 
        if ftype == TType.MAP:
16687 
          self.success = {}
7438 amit.gupta 16688 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16689 
          for _i318 in xrange(_size314):
16690 
            _key319 = iprot.readString();
16691 
            _val320 = BrandInfo()
16692 
            _val320.read(iprot)
16693 
            self.success[_key319] = _val320
7272 amit.gupta 16694 
          iprot.readMapEnd()
16695 
        else:
16696 
          iprot.skip(ftype)
16697 
      else:
16698 
        iprot.skip(ftype)
16699 
      iprot.readFieldEnd()
16700 
    iprot.readStructEnd()
16701 
 
16702 
  def write(self, oprot):
16703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16705 
      return
16706 
    oprot.writeStructBegin('getBrandInfo_result')
16707 
    if self.success is not None:
16708 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16709 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16710 
      for kiter321,viter322 in self.success.items():
16711 
        oprot.writeString(kiter321)
16712 
        viter322.write(oprot)
7272 amit.gupta 16713 
      oprot.writeMapEnd()
16714 
      oprot.writeFieldEnd()
16715 
    oprot.writeFieldStop()
16716 
    oprot.writeStructEnd()
16717 
 
16718 
  def validate(self):
16719 
    return
16720 
 
16721 
 
16722 
  def __repr__(self):
16723 
    L = ['%s=%r' % (key, value)
16724 
      for key, value in self.__dict__.iteritems()]
16725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16726 
 
16727 
  def __eq__(self, other):
16728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16729 
 
16730 
  def __ne__(self, other):
16731 
    return not (self == other)
16732 
 
7256 rajveer 16733 
class getStorePricing_args:
16734 
  """
16735 
  Attributes:
16736 
   - itemId
16737 
  """
16738 
 
16739 
  thrift_spec = (
16740 
    None, # 0
16741 
    (1, TType.I64, 'itemId', None, None, ), # 1
16742 
  )
16743 
 
16744 
  def __init__(self, itemId=None,):
16745 
    self.itemId = itemId
16746 
 
16747 
  def read(self, iprot):
16748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16750 
      return
16751 
    iprot.readStructBegin()
16752 
    while True:
16753 
      (fname, ftype, fid) = iprot.readFieldBegin()
16754 
      if ftype == TType.STOP:
16755 
        break
16756 
      if fid == 1:
16757 
        if ftype == TType.I64:
16758 
          self.itemId = iprot.readI64();
16759 
        else:
16760 
          iprot.skip(ftype)
16761 
      else:
16762 
        iprot.skip(ftype)
16763 
      iprot.readFieldEnd()
16764 
    iprot.readStructEnd()
16765 
 
16766 
  def write(self, oprot):
16767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16769 
      return
16770 
    oprot.writeStructBegin('getStorePricing_args')
16771 
    if self.itemId is not None:
16772 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16773 
      oprot.writeI64(self.itemId)
16774 
      oprot.writeFieldEnd()
16775 
    oprot.writeFieldStop()
16776 
    oprot.writeStructEnd()
16777 
 
16778 
  def validate(self):
16779 
    return
16780 
 
16781 
 
16782 
  def __repr__(self):
16783 
    L = ['%s=%r' % (key, value)
16784 
      for key, value in self.__dict__.iteritems()]
16785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16786 
 
16787 
  def __eq__(self, other):
16788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16789 
 
16790 
  def __ne__(self, other):
16791 
    return not (self == other)
16792 
 
16793 
class getStorePricing_result:
16794 
  """
16795 
  Attributes:
16796 
   - success
16797 
  """
16798 
 
16799 
  thrift_spec = (
16800 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16801 
  )
16802 
 
16803 
  def __init__(self, success=None,):
16804 
    self.success = success
16805 
 
16806 
  def read(self, iprot):
16807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16809 
      return
16810 
    iprot.readStructBegin()
16811 
    while True:
16812 
      (fname, ftype, fid) = iprot.readFieldBegin()
16813 
      if ftype == TType.STOP:
16814 
        break
16815 
      if fid == 0:
16816 
        if ftype == TType.STRUCT:
16817 
          self.success = StorePricing()
16818 
          self.success.read(iprot)
16819 
        else:
16820 
          iprot.skip(ftype)
16821 
      else:
16822 
        iprot.skip(ftype)
16823 
      iprot.readFieldEnd()
16824 
    iprot.readStructEnd()
16825 
 
16826 
  def write(self, oprot):
16827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16829 
      return
16830 
    oprot.writeStructBegin('getStorePricing_result')
16831 
    if self.success is not None:
16832 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16833 
      self.success.write(oprot)
16834 
      oprot.writeFieldEnd()
16835 
    oprot.writeFieldStop()
16836 
    oprot.writeStructEnd()
16837 
 
16838 
  def validate(self):
16839 
    return
16840 
 
16841 
 
16842 
  def __repr__(self):
16843 
    L = ['%s=%r' % (key, value)
16844 
      for key, value in self.__dict__.iteritems()]
16845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16846 
 
16847 
  def __eq__(self, other):
16848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16849 
 
16850 
  def __ne__(self, other):
16851 
    return not (self == other)
7265 rajveer 16852 
 
7306 rajveer 16853 
class getStorePricings_args:
16854 
  """
16855 
  Attributes:
16856 
   - itemIds
16857 
  """
16858 
 
16859 
  thrift_spec = (
16860 
    None, # 0
16861 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16862 
  )
16863 
 
16864 
  def __init__(self, itemIds=None,):
16865 
    self.itemIds = itemIds
16866 
 
16867 
  def read(self, iprot):
16868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16870 
      return
16871 
    iprot.readStructBegin()
16872 
    while True:
16873 
      (fname, ftype, fid) = iprot.readFieldBegin()
16874 
      if ftype == TType.STOP:
16875 
        break
16876 
      if fid == 1:
16877 
        if ftype == TType.LIST:
16878 
          self.itemIds = []
7438 amit.gupta 16879 
          (_etype326, _size323) = iprot.readListBegin()
16880 
          for _i327 in xrange(_size323):
16881 
            _elem328 = iprot.readI64();
16882 
            self.itemIds.append(_elem328)
7306 rajveer 16883 
          iprot.readListEnd()
16884 
        else:
16885 
          iprot.skip(ftype)
16886 
      else:
16887 
        iprot.skip(ftype)
16888 
      iprot.readFieldEnd()
16889 
    iprot.readStructEnd()
16890 
 
16891 
  def write(self, oprot):
16892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16894 
      return
16895 
    oprot.writeStructBegin('getStorePricings_args')
16896 
    if self.itemIds is not None:
16897 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16898 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 16899 
      for iter329 in self.itemIds:
16900 
        oprot.writeI64(iter329)
7306 rajveer 16901 
      oprot.writeListEnd()
16902 
      oprot.writeFieldEnd()
16903 
    oprot.writeFieldStop()
16904 
    oprot.writeStructEnd()
16905 
 
16906 
  def validate(self):
16907 
    return
16908 
 
16909 
 
16910 
  def __repr__(self):
16911 
    L = ['%s=%r' % (key, value)
16912 
      for key, value in self.__dict__.iteritems()]
16913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16914 
 
16915 
  def __eq__(self, other):
16916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16917 
 
16918 
  def __ne__(self, other):
16919 
    return not (self == other)
16920 
 
16921 
class getStorePricings_result:
16922 
  """
16923 
  Attributes:
16924 
   - success
16925 
  """
16926 
 
16927 
  thrift_spec = (
16928 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16929 
  )
16930 
 
16931 
  def __init__(self, success=None,):
16932 
    self.success = success
16933 
 
16934 
  def read(self, iprot):
16935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16937 
      return
16938 
    iprot.readStructBegin()
16939 
    while True:
16940 
      (fname, ftype, fid) = iprot.readFieldBegin()
16941 
      if ftype == TType.STOP:
16942 
        break
16943 
      if fid == 0:
16944 
        if ftype == TType.LIST:
16945 
          self.success = []
7438 amit.gupta 16946 
          (_etype333, _size330) = iprot.readListBegin()
16947 
          for _i334 in xrange(_size330):
16948 
            _elem335 = StorePricing()
16949 
            _elem335.read(iprot)
16950 
            self.success.append(_elem335)
7306 rajveer 16951 
          iprot.readListEnd()
16952 
        else:
16953 
          iprot.skip(ftype)
16954 
      else:
16955 
        iprot.skip(ftype)
16956 
      iprot.readFieldEnd()
16957 
    iprot.readStructEnd()
16958 
 
16959 
  def write(self, oprot):
16960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16962 
      return
16963 
    oprot.writeStructBegin('getStorePricings_result')
16964 
    if self.success is not None:
16965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16967 
      for iter336 in self.success:
16968 
        iter336.write(oprot)
7306 rajveer 16969 
      oprot.writeListEnd()
16970 
      oprot.writeFieldEnd()
16971 
    oprot.writeFieldStop()
16972 
    oprot.writeStructEnd()
16973 
 
16974 
  def validate(self):
16975 
    return
16976 
 
16977 
 
16978 
  def __repr__(self):
16979 
    L = ['%s=%r' % (key, value)
16980 
      for key, value in self.__dict__.iteritems()]
16981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16982 
 
16983 
  def __eq__(self, other):
16984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16985 
 
16986 
  def __ne__(self, other):
16987 
    return not (self == other)
16988 
 
7265 rajveer 16989 
class updateStorePricing_args:
16990 
  """
16991 
  Attributes:
16992 
   - sp
7382 rajveer 16993 
   - allColors
7265 rajveer 16994 
  """
16995 
 
16996 
  thrift_spec = (
16997 
    None, # 0
16998 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 16999 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 17000 
  )
17001 
 
7382 rajveer 17002 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 17003 
    self.sp = sp
7382 rajveer 17004 
    self.allColors = allColors
7265 rajveer 17005 
 
17006 
  def read(self, iprot):
17007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17009 
      return
17010 
    iprot.readStructBegin()
17011 
    while True:
17012 
      (fname, ftype, fid) = iprot.readFieldBegin()
17013 
      if ftype == TType.STOP:
17014 
        break
17015 
      if fid == 1:
17016 
        if ftype == TType.STRUCT:
17017 
          self.sp = StorePricing()
17018 
          self.sp.read(iprot)
17019 
        else:
17020 
          iprot.skip(ftype)
7382 rajveer 17021 
      elif fid == 2:
17022 
        if ftype == TType.BOOL:
17023 
          self.allColors = iprot.readBool();
17024 
        else:
17025 
          iprot.skip(ftype)
7265 rajveer 17026 
      else:
17027 
        iprot.skip(ftype)
17028 
      iprot.readFieldEnd()
17029 
    iprot.readStructEnd()
17030 
 
17031 
  def write(self, oprot):
17032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17034 
      return
17035 
    oprot.writeStructBegin('updateStorePricing_args')
17036 
    if self.sp is not None:
17037 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
17038 
      self.sp.write(oprot)
17039 
      oprot.writeFieldEnd()
7382 rajveer 17040 
    if self.allColors is not None:
17041 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
17042 
      oprot.writeBool(self.allColors)
17043 
      oprot.writeFieldEnd()
7265 rajveer 17044 
    oprot.writeFieldStop()
17045 
    oprot.writeStructEnd()
17046 
 
17047 
  def validate(self):
17048 
    return
17049 
 
17050 
 
17051 
  def __repr__(self):
17052 
    L = ['%s=%r' % (key, value)
17053 
      for key, value in self.__dict__.iteritems()]
17054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17055 
 
17056 
  def __eq__(self, other):
17057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17058 
 
17059 
  def __ne__(self, other):
17060 
    return not (self == other)
17061 
 
17062 
class updateStorePricing_result:
17063 
 
17064 
  thrift_spec = (
17065 
  )
17066 
 
17067 
  def read(self, iprot):
17068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17070 
      return
17071 
    iprot.readStructBegin()
17072 
    while True:
17073 
      (fname, ftype, fid) = iprot.readFieldBegin()
17074 
      if ftype == TType.STOP:
17075 
        break
17076 
      else:
17077 
        iprot.skip(ftype)
17078 
      iprot.readFieldEnd()
17079 
    iprot.readStructEnd()
17080 
 
17081 
  def write(self, oprot):
17082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17084 
      return
17085 
    oprot.writeStructBegin('updateStorePricing_result')
17086 
    oprot.writeFieldStop()
17087 
    oprot.writeStructEnd()
17088 
 
17089 
  def validate(self):
17090 
    return
17091 
 
17092 
 
17093 
  def __repr__(self):
17094 
    L = ['%s=%r' % (key, value)
17095 
      for key, value in self.__dict__.iteritems()]
17096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17097 
 
17098 
  def __eq__(self, other):
17099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17100 
 
17101 
  def __ne__(self, other):
17102 
    return not (self == other)
7281 kshitij.so 17103 
 
17104 
class getAllAmazonListedItems_args:
17105 
 
17106 
  thrift_spec = (
17107 
  )
17108 
 
17109 
  def read(self, iprot):
17110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17112 
      return
17113 
    iprot.readStructBegin()
17114 
    while True:
17115 
      (fname, ftype, fid) = iprot.readFieldBegin()
17116 
      if ftype == TType.STOP:
17117 
        break
17118 
      else:
17119 
        iprot.skip(ftype)
17120 
      iprot.readFieldEnd()
17121 
    iprot.readStructEnd()
17122 
 
17123 
  def write(self, oprot):
17124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17126 
      return
17127 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17128 
    oprot.writeFieldStop()
17129 
    oprot.writeStructEnd()
17130 
 
17131 
  def validate(self):
17132 
    return
17133 
 
17134 
 
17135 
  def __repr__(self):
17136 
    L = ['%s=%r' % (key, value)
17137 
      for key, value in self.__dict__.iteritems()]
17138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17139 
 
17140 
  def __eq__(self, other):
17141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17142 
 
17143 
  def __ne__(self, other):
17144 
    return not (self == other)
17145 
 
17146 
class getAllAmazonListedItems_result:
17147 
  """
17148 
  Attributes:
17149 
   - success
17150 
  """
17151 
 
17152 
  thrift_spec = (
17153 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17154 
  )
17155 
 
17156 
  def __init__(self, success=None,):
17157 
    self.success = success
17158 
 
17159 
  def read(self, iprot):
17160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17162 
      return
17163 
    iprot.readStructBegin()
17164 
    while True:
17165 
      (fname, ftype, fid) = iprot.readFieldBegin()
17166 
      if ftype == TType.STOP:
17167 
        break
17168 
      if fid == 0:
17169 
        if ftype == TType.LIST:
17170 
          self.success = []
7438 amit.gupta 17171 
          (_etype340, _size337) = iprot.readListBegin()
17172 
          for _i341 in xrange(_size337):
17173 
            _elem342 = Amazonlisted()
17174 
            _elem342.read(iprot)
17175 
            self.success.append(_elem342)
7281 kshitij.so 17176 
          iprot.readListEnd()
17177 
        else:
17178 
          iprot.skip(ftype)
17179 
      else:
17180 
        iprot.skip(ftype)
17181 
      iprot.readFieldEnd()
17182 
    iprot.readStructEnd()
17183 
 
17184 
  def write(self, oprot):
17185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17187 
      return
17188 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17189 
    if self.success is not None:
17190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17192 
      for iter343 in self.success:
17193 
        iter343.write(oprot)
7281 kshitij.so 17194 
      oprot.writeListEnd()
17195 
      oprot.writeFieldEnd()
17196 
    oprot.writeFieldStop()
17197 
    oprot.writeStructEnd()
17198 
 
17199 
  def validate(self):
17200 
    return
17201 
 
17202 
 
17203 
  def __repr__(self):
17204 
    L = ['%s=%r' % (key, value)
17205 
      for key, value in self.__dict__.iteritems()]
17206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17207 
 
17208 
  def __eq__(self, other):
17209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17210 
 
17211 
  def __ne__(self, other):
17212 
    return not (self == other)
17213 
 
17214 
class getAmazonItemDetails_args:
17215 
  """
17216 
  Attributes:
17217 
   - itemId
17218 
  """
17219 
 
17220 
  thrift_spec = (
17221 
    None, # 0
17222 
    (1, TType.I64, 'itemId', None, None, ), # 1
17223 
  )
17224 
 
17225 
  def __init__(self, itemId=None,):
17226 
    self.itemId = itemId
17227 
 
17228 
  def read(self, iprot):
17229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17231 
      return
17232 
    iprot.readStructBegin()
17233 
    while True:
17234 
      (fname, ftype, fid) = iprot.readFieldBegin()
17235 
      if ftype == TType.STOP:
17236 
        break
17237 
      if fid == 1:
17238 
        if ftype == TType.I64:
17239 
          self.itemId = iprot.readI64();
17240 
        else:
17241 
          iprot.skip(ftype)
17242 
      else:
17243 
        iprot.skip(ftype)
17244 
      iprot.readFieldEnd()
17245 
    iprot.readStructEnd()
17246 
 
17247 
  def write(self, oprot):
17248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17250 
      return
17251 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17252 
    if self.itemId is not None:
17253 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17254 
      oprot.writeI64(self.itemId)
17255 
      oprot.writeFieldEnd()
17256 
    oprot.writeFieldStop()
17257 
    oprot.writeStructEnd()
17258 
 
17259 
  def validate(self):
17260 
    return
17261 
 
17262 
 
17263 
  def __repr__(self):
17264 
    L = ['%s=%r' % (key, value)
17265 
      for key, value in self.__dict__.iteritems()]
17266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17267 
 
17268 
  def __eq__(self, other):
17269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17270 
 
17271 
  def __ne__(self, other):
17272 
    return not (self == other)
17273 
 
17274 
class getAmazonItemDetails_result:
17275 
  """
17276 
  Attributes:
17277 
   - success
17278 
  """
17279 
 
17280 
  thrift_spec = (
17281 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17282 
  )
17283 
 
17284 
  def __init__(self, success=None,):
17285 
    self.success = success
17286 
 
17287 
  def read(self, iprot):
17288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17290 
      return
17291 
    iprot.readStructBegin()
17292 
    while True:
17293 
      (fname, ftype, fid) = iprot.readFieldBegin()
17294 
      if ftype == TType.STOP:
17295 
        break
17296 
      if fid == 0:
17297 
        if ftype == TType.STRUCT:
17298 
          self.success = Amazonlisted()
17299 
          self.success.read(iprot)
17300 
        else:
17301 
          iprot.skip(ftype)
17302 
      else:
17303 
        iprot.skip(ftype)
17304 
      iprot.readFieldEnd()
17305 
    iprot.readStructEnd()
17306 
 
17307 
  def write(self, oprot):
17308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17310 
      return
17311 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17312 
    if self.success is not None:
17313 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17314 
      self.success.write(oprot)
17315 
      oprot.writeFieldEnd()
17316 
    oprot.writeFieldStop()
17317 
    oprot.writeStructEnd()
17318 
 
17319 
  def validate(self):
17320 
    return
17321 
 
17322 
 
17323 
  def __repr__(self):
17324 
    L = ['%s=%r' % (key, value)
17325 
      for key, value in self.__dict__.iteritems()]
17326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17327 
 
17328 
  def __eq__(self, other):
17329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17330 
 
17331 
  def __ne__(self, other):
17332 
    return not (self == other)
17333 
 
17334 
class updateAmazonItemDetails_args:
17335 
  """
17336 
  Attributes:
17337 
   - itemId
17338 
   - fbaPrice
17339 
   - sellingPrice
17340 
   - isFba
17341 
   - isNonFba
17342 
   - isInventoryOverride
7367 kshitij.so 17343 
   - handlingTime
17344 
   - isCustomTime
7281 kshitij.so 17345 
  """
17346 
 
17347 
  thrift_spec = (
17348 
    None, # 0
17349 
    (1, TType.I64, 'itemId', None, None, ), # 1
17350 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
17351 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
17352 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
17353 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
17354 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 17355 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
17356 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 17357 
  )
17358 
 
7367 kshitij.so 17359 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 17360 
    self.itemId = itemId
17361 
    self.fbaPrice = fbaPrice
17362 
    self.sellingPrice = sellingPrice
17363 
    self.isFba = isFba
17364 
    self.isNonFba = isNonFba
17365 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 17366 
    self.handlingTime = handlingTime
17367 
    self.isCustomTime = isCustomTime
7281 kshitij.so 17368 
 
17369 
  def read(self, iprot):
17370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17372 
      return
17373 
    iprot.readStructBegin()
17374 
    while True:
17375 
      (fname, ftype, fid) = iprot.readFieldBegin()
17376 
      if ftype == TType.STOP:
17377 
        break
17378 
      if fid == 1:
17379 
        if ftype == TType.I64:
17380 
          self.itemId = iprot.readI64();
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      elif fid == 2:
17384 
        if ftype == TType.DOUBLE:
17385 
          self.fbaPrice = iprot.readDouble();
17386 
        else:
17387 
          iprot.skip(ftype)
17388 
      elif fid == 3:
17389 
        if ftype == TType.DOUBLE:
17390 
          self.sellingPrice = iprot.readDouble();
17391 
        else:
17392 
          iprot.skip(ftype)
17393 
      elif fid == 4:
17394 
        if ftype == TType.BOOL:
17395 
          self.isFba = iprot.readBool();
17396 
        else:
17397 
          iprot.skip(ftype)
17398 
      elif fid == 5:
17399 
        if ftype == TType.BOOL:
17400 
          self.isNonFba = iprot.readBool();
17401 
        else:
17402 
          iprot.skip(ftype)
17403 
      elif fid == 6:
17404 
        if ftype == TType.BOOL:
17405 
          self.isInventoryOverride = iprot.readBool();
17406 
        else:
17407 
          iprot.skip(ftype)
7367 kshitij.so 17408 
      elif fid == 7:
17409 
        if ftype == TType.I64:
17410 
          self.handlingTime = iprot.readI64();
17411 
        else:
17412 
          iprot.skip(ftype)
17413 
      elif fid == 8:
17414 
        if ftype == TType.BOOL:
17415 
          self.isCustomTime = iprot.readBool();
17416 
        else:
17417 
          iprot.skip(ftype)
7281 kshitij.so 17418 
      else:
17419 
        iprot.skip(ftype)
17420 
      iprot.readFieldEnd()
17421 
    iprot.readStructEnd()
17422 
 
17423 
  def write(self, oprot):
17424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17426 
      return
17427 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17428 
    if self.itemId is not None:
17429 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17430 
      oprot.writeI64(self.itemId)
17431 
      oprot.writeFieldEnd()
17432 
    if self.fbaPrice is not None:
17433 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17434 
      oprot.writeDouble(self.fbaPrice)
17435 
      oprot.writeFieldEnd()
17436 
    if self.sellingPrice is not None:
17437 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17438 
      oprot.writeDouble(self.sellingPrice)
17439 
      oprot.writeFieldEnd()
17440 
    if self.isFba is not None:
17441 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17442 
      oprot.writeBool(self.isFba)
17443 
      oprot.writeFieldEnd()
17444 
    if self.isNonFba is not None:
17445 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17446 
      oprot.writeBool(self.isNonFba)
17447 
      oprot.writeFieldEnd()
17448 
    if self.isInventoryOverride is not None:
17449 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17450 
      oprot.writeBool(self.isInventoryOverride)
17451 
      oprot.writeFieldEnd()
7367 kshitij.so 17452 
    if self.handlingTime is not None:
17453 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17454 
      oprot.writeI64(self.handlingTime)
17455 
      oprot.writeFieldEnd()
17456 
    if self.isCustomTime is not None:
17457 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17458 
      oprot.writeBool(self.isCustomTime)
17459 
      oprot.writeFieldEnd()
7281 kshitij.so 17460 
    oprot.writeFieldStop()
17461 
    oprot.writeStructEnd()
17462 
 
17463 
  def validate(self):
17464 
    return
17465 
 
17466 
 
17467 
  def __repr__(self):
17468 
    L = ['%s=%r' % (key, value)
17469 
      for key, value in self.__dict__.iteritems()]
17470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17471 
 
17472 
  def __eq__(self, other):
17473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17474 
 
17475 
  def __ne__(self, other):
17476 
    return not (self == other)
17477 
 
17478 
class updateAmazonItemDetails_result:
17479 
 
17480 
  thrift_spec = (
17481 
  )
17482 
 
17483 
  def read(self, iprot):
17484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17486 
      return
17487 
    iprot.readStructBegin()
17488 
    while True:
17489 
      (fname, ftype, fid) = iprot.readFieldBegin()
17490 
      if ftype == TType.STOP:
17491 
        break
17492 
      else:
17493 
        iprot.skip(ftype)
17494 
      iprot.readFieldEnd()
17495 
    iprot.readStructEnd()
17496 
 
17497 
  def write(self, oprot):
17498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17500 
      return
17501 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17502 
    oprot.writeFieldStop()
17503 
    oprot.writeStructEnd()
17504 
 
17505 
  def validate(self):
17506 
    return
17507 
 
17508 
 
17509 
  def __repr__(self):
17510 
    L = ['%s=%r' % (key, value)
17511 
      for key, value in self.__dict__.iteritems()]
17512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17513 
 
17514 
  def __eq__(self, other):
17515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17516 
 
17517 
  def __ne__(self, other):
17518 
    return not (self == other)
17519 
 
17520 
class addAmazonItem_args:
17521 
  """
17522 
  Attributes:
17523 
   - amazonlisted
17524 
  """
17525 
 
17526 
  thrift_spec = (
17527 
    None, # 0
17528 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17529 
  )
17530 
 
17531 
  def __init__(self, amazonlisted=None,):
17532 
    self.amazonlisted = amazonlisted
17533 
 
17534 
  def read(self, iprot):
17535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17537 
      return
17538 
    iprot.readStructBegin()
17539 
    while True:
17540 
      (fname, ftype, fid) = iprot.readFieldBegin()
17541 
      if ftype == TType.STOP:
17542 
        break
17543 
      if fid == 1:
17544 
        if ftype == TType.STRUCT:
17545 
          self.amazonlisted = Amazonlisted()
17546 
          self.amazonlisted.read(iprot)
17547 
        else:
17548 
          iprot.skip(ftype)
17549 
      else:
17550 
        iprot.skip(ftype)
17551 
      iprot.readFieldEnd()
17552 
    iprot.readStructEnd()
17553 
 
17554 
  def write(self, oprot):
17555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17557 
      return
17558 
    oprot.writeStructBegin('addAmazonItem_args')
17559 
    if self.amazonlisted is not None:
17560 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17561 
      self.amazonlisted.write(oprot)
17562 
      oprot.writeFieldEnd()
17563 
    oprot.writeFieldStop()
17564 
    oprot.writeStructEnd()
17565 
 
17566 
  def validate(self):
17567 
    return
17568 
 
17569 
 
17570 
  def __repr__(self):
17571 
    L = ['%s=%r' % (key, value)
17572 
      for key, value in self.__dict__.iteritems()]
17573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17574 
 
17575 
  def __eq__(self, other):
17576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17577 
 
17578 
  def __ne__(self, other):
17579 
    return not (self == other)
17580 
 
17581 
class addAmazonItem_result:
17582 
 
17583 
  thrift_spec = (
17584 
  )
17585 
 
17586 
  def read(self, iprot):
17587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17589 
      return
17590 
    iprot.readStructBegin()
17591 
    while True:
17592 
      (fname, ftype, fid) = iprot.readFieldBegin()
17593 
      if ftype == TType.STOP:
17594 
        break
17595 
      else:
17596 
        iprot.skip(ftype)
17597 
      iprot.readFieldEnd()
17598 
    iprot.readStructEnd()
17599 
 
17600 
  def write(self, oprot):
17601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17603 
      return
17604 
    oprot.writeStructBegin('addAmazonItem_result')
17605 
    oprot.writeFieldStop()
17606 
    oprot.writeStructEnd()
17607 
 
17608 
  def validate(self):
17609 
    return
17610 
 
17611 
 
17612 
  def __repr__(self):
17613 
    L = ['%s=%r' % (key, value)
17614 
      for key, value in self.__dict__.iteritems()]
17615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17616 
 
17617 
  def __eq__(self, other):
17618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17619 
 
17620 
  def __ne__(self, other):
17621 
    return not (self == other)
7291 vikram.rag 17622 
 
17623 
class getAsinItems_args:
17624 
 
17625 
  thrift_spec = (
17626 
  )
17627 
 
17628 
  def read(self, iprot):
17629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17631 
      return
17632 
    iprot.readStructBegin()
17633 
    while True:
17634 
      (fname, ftype, fid) = iprot.readFieldBegin()
17635 
      if ftype == TType.STOP:
17636 
        break
17637 
      else:
17638 
        iprot.skip(ftype)
17639 
      iprot.readFieldEnd()
17640 
    iprot.readStructEnd()
17641 
 
17642 
  def write(self, oprot):
17643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17645 
      return
17646 
    oprot.writeStructBegin('getAsinItems_args')
17647 
    oprot.writeFieldStop()
17648 
    oprot.writeStructEnd()
17649 
 
17650 
  def validate(self):
17651 
    return
17652 
 
17653 
 
17654 
  def __repr__(self):
17655 
    L = ['%s=%r' % (key, value)
17656 
      for key, value in self.__dict__.iteritems()]
17657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17658 
 
17659 
  def __eq__(self, other):
17660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17661 
 
17662 
  def __ne__(self, other):
17663 
    return not (self == other)
17664 
 
17665 
class getAsinItems_result:
17666 
  """
17667 
  Attributes:
17668 
   - success
17669 
  """
17670 
 
17671 
  thrift_spec = (
17672 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17673 
  )
17674 
 
17675 
  def __init__(self, success=None,):
17676 
    self.success = success
17677 
 
17678 
  def read(self, iprot):
17679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17681 
      return
17682 
    iprot.readStructBegin()
17683 
    while True:
17684 
      (fname, ftype, fid) = iprot.readFieldBegin()
17685 
      if ftype == TType.STOP:
17686 
        break
17687 
      if fid == 0:
17688 
        if ftype == TType.LIST:
17689 
          self.success = []
7438 amit.gupta 17690 
          (_etype347, _size344) = iprot.readListBegin()
17691 
          for _i348 in xrange(_size344):
17692 
            _elem349 = Item()
17693 
            _elem349.read(iprot)
17694 
            self.success.append(_elem349)
7291 vikram.rag 17695 
          iprot.readListEnd()
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      else:
17699 
        iprot.skip(ftype)
17700 
      iprot.readFieldEnd()
17701 
    iprot.readStructEnd()
17702 
 
17703 
  def write(self, oprot):
17704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17706 
      return
17707 
    oprot.writeStructBegin('getAsinItems_result')
17708 
    if self.success is not None:
17709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17711 
      for iter350 in self.success:
17712 
        iter350.write(oprot)
7291 vikram.rag 17713 
      oprot.writeListEnd()
17714 
      oprot.writeFieldEnd()
17715 
    oprot.writeFieldStop()
17716 
    oprot.writeStructEnd()
17717 
 
17718 
  def validate(self):
17719 
    return
17720 
 
17721 
 
17722 
  def __repr__(self):
17723 
    L = ['%s=%r' % (key, value)
17724 
      for key, value in self.__dict__.iteritems()]
17725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17726 
 
17727 
  def __eq__(self, other):
17728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17729 
 
17730 
  def __ne__(self, other):
17731 
    return not (self == other)
17732 
 
17733 
class getAllFbaListedItems_args:
17734 
 
17735 
  thrift_spec = (
17736 
  )
17737 
 
17738 
  def read(self, iprot):
17739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17741 
      return
17742 
    iprot.readStructBegin()
17743 
    while True:
17744 
      (fname, ftype, fid) = iprot.readFieldBegin()
17745 
      if ftype == TType.STOP:
17746 
        break
17747 
      else:
17748 
        iprot.skip(ftype)
17749 
      iprot.readFieldEnd()
17750 
    iprot.readStructEnd()
17751 
 
17752 
  def write(self, oprot):
17753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17755 
      return
17756 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17757 
    oprot.writeFieldStop()
17758 
    oprot.writeStructEnd()
17759 
 
17760 
  def validate(self):
17761 
    return
17762 
 
17763 
 
17764 
  def __repr__(self):
17765 
    L = ['%s=%r' % (key, value)
17766 
      for key, value in self.__dict__.iteritems()]
17767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17768 
 
17769 
  def __eq__(self, other):
17770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17771 
 
17772 
  def __ne__(self, other):
17773 
    return not (self == other)
17774 
 
17775 
class getAllFbaListedItems_result:
17776 
  """
17777 
  Attributes:
17778 
   - success
17779 
  """
17780 
 
17781 
  thrift_spec = (
17782 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17783 
  )
17784 
 
17785 
  def __init__(self, success=None,):
17786 
    self.success = success
17787 
 
17788 
  def read(self, iprot):
17789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17791 
      return
17792 
    iprot.readStructBegin()
17793 
    while True:
17794 
      (fname, ftype, fid) = iprot.readFieldBegin()
17795 
      if ftype == TType.STOP:
17796 
        break
17797 
      if fid == 0:
17798 
        if ftype == TType.LIST:
17799 
          self.success = []
7438 amit.gupta 17800 
          (_etype354, _size351) = iprot.readListBegin()
17801 
          for _i355 in xrange(_size351):
17802 
            _elem356 = Amazonlisted()
17803 
            _elem356.read(iprot)
17804 
            self.success.append(_elem356)
7291 vikram.rag 17805 
          iprot.readListEnd()
17806 
        else:
17807 
          iprot.skip(ftype)
17808 
      else:
17809 
        iprot.skip(ftype)
17810 
      iprot.readFieldEnd()
17811 
    iprot.readStructEnd()
17812 
 
17813 
  def write(self, oprot):
17814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17816 
      return
17817 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17818 
    if self.success is not None:
17819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17821 
      for iter357 in self.success:
17822 
        iter357.write(oprot)
7291 vikram.rag 17823 
      oprot.writeListEnd()
17824 
      oprot.writeFieldEnd()
17825 
    oprot.writeFieldStop()
17826 
    oprot.writeStructEnd()
17827 
 
17828 
  def validate(self):
17829 
    return
17830 
 
17831 
 
17832 
  def __repr__(self):
17833 
    L = ['%s=%r' % (key, value)
17834 
      for key, value in self.__dict__.iteritems()]
17835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17836 
 
17837 
  def __eq__(self, other):
17838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17839 
 
17840 
  def __ne__(self, other):
17841 
    return not (self == other)
17842 
 
17843 
class getAllNonFbaListedItems_args:
17844 
 
17845 
  thrift_spec = (
17846 
  )
17847 
 
17848 
  def read(self, iprot):
17849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17851 
      return
17852 
    iprot.readStructBegin()
17853 
    while True:
17854 
      (fname, ftype, fid) = iprot.readFieldBegin()
17855 
      if ftype == TType.STOP:
17856 
        break
17857 
      else:
17858 
        iprot.skip(ftype)
17859 
      iprot.readFieldEnd()
17860 
    iprot.readStructEnd()
17861 
 
17862 
  def write(self, oprot):
17863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17865 
      return
17866 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17867 
    oprot.writeFieldStop()
17868 
    oprot.writeStructEnd()
17869 
 
17870 
  def validate(self):
17871 
    return
17872 
 
17873 
 
17874 
  def __repr__(self):
17875 
    L = ['%s=%r' % (key, value)
17876 
      for key, value in self.__dict__.iteritems()]
17877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17878 
 
17879 
  def __eq__(self, other):
17880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17881 
 
17882 
  def __ne__(self, other):
17883 
    return not (self == other)
17884 
 
17885 
class getAllNonFbaListedItems_result:
17886 
  """
17887 
  Attributes:
17888 
   - success
17889 
  """
17890 
 
17891 
  thrift_spec = (
17892 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17893 
  )
17894 
 
17895 
  def __init__(self, success=None,):
17896 
    self.success = success
17897 
 
17898 
  def read(self, iprot):
17899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17901 
      return
17902 
    iprot.readStructBegin()
17903 
    while True:
17904 
      (fname, ftype, fid) = iprot.readFieldBegin()
17905 
      if ftype == TType.STOP:
17906 
        break
17907 
      if fid == 0:
17908 
        if ftype == TType.LIST:
17909 
          self.success = []
7438 amit.gupta 17910 
          (_etype361, _size358) = iprot.readListBegin()
17911 
          for _i362 in xrange(_size358):
17912 
            _elem363 = Amazonlisted()
17913 
            _elem363.read(iprot)
17914 
            self.success.append(_elem363)
7291 vikram.rag 17915 
          iprot.readListEnd()
17916 
        else:
17917 
          iprot.skip(ftype)
17918 
      else:
17919 
        iprot.skip(ftype)
17920 
      iprot.readFieldEnd()
17921 
    iprot.readStructEnd()
17922 
 
17923 
  def write(self, oprot):
17924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17926 
      return
17927 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17928 
    if self.success is not None:
17929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17931 
      for iter364 in self.success:
17932 
        iter364.write(oprot)
7291 vikram.rag 17933 
      oprot.writeListEnd()
17934 
      oprot.writeFieldEnd()
17935 
    oprot.writeFieldStop()
17936 
    oprot.writeStructEnd()
17937 
 
17938 
  def validate(self):
17939 
    return
17940 
 
17941 
 
17942 
  def __repr__(self):
17943 
    L = ['%s=%r' % (key, value)
17944 
      for key, value in self.__dict__.iteritems()]
17945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17946 
 
17947 
  def __eq__(self, other):
17948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17949 
 
17950 
  def __ne__(self, other):
17951 
    return not (self == other)
7460 kshitij.so 17952 
 
17953 
class updateItemInventory_args:
17954 
  """
17955 
  Attributes:
17956 
   - itemId
17957 
   - holdInventory
17958 
   - defaultInventory
17959 
  """
17960 
 
17961 
  thrift_spec = (
17962 
    None, # 0
17963 
    (1, TType.I64, 'itemId', None, None, ), # 1
17964 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
17965 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
17966 
  )
17967 
 
17968 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
17969 
    self.itemId = itemId
17970 
    self.holdInventory = holdInventory
17971 
    self.defaultInventory = defaultInventory
17972 
 
17973 
  def read(self, iprot):
17974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17976 
      return
17977 
    iprot.readStructBegin()
17978 
    while True:
17979 
      (fname, ftype, fid) = iprot.readFieldBegin()
17980 
      if ftype == TType.STOP:
17981 
        break
17982 
      if fid == 1:
17983 
        if ftype == TType.I64:
17984 
          self.itemId = iprot.readI64();
17985 
        else:
17986 
          iprot.skip(ftype)
17987 
      elif fid == 2:
17988 
        if ftype == TType.I64:
17989 
          self.holdInventory = iprot.readI64();
17990 
        else:
17991 
          iprot.skip(ftype)
17992 
      elif fid == 3:
17993 
        if ftype == TType.I64:
17994 
          self.defaultInventory = iprot.readI64();
17995 
        else:
17996 
          iprot.skip(ftype)
17997 
      else:
17998 
        iprot.skip(ftype)
17999 
      iprot.readFieldEnd()
18000 
    iprot.readStructEnd()
18001 
 
18002 
  def write(self, oprot):
18003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18005 
      return
18006 
    oprot.writeStructBegin('updateItemInventory_args')
18007 
    if self.itemId is not None:
18008 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18009 
      oprot.writeI64(self.itemId)
18010 
      oprot.writeFieldEnd()
18011 
    if self.holdInventory is not None:
18012 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
18013 
      oprot.writeI64(self.holdInventory)
18014 
      oprot.writeFieldEnd()
18015 
    if self.defaultInventory is not None:
18016 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
18017 
      oprot.writeI64(self.defaultInventory)
18018 
      oprot.writeFieldEnd()
18019 
    oprot.writeFieldStop()
18020 
    oprot.writeStructEnd()
18021 
 
18022 
  def validate(self):
18023 
    return
18024 
 
18025 
 
18026 
  def __repr__(self):
18027 
    L = ['%s=%r' % (key, value)
18028 
      for key, value in self.__dict__.iteritems()]
18029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18030 
 
18031 
  def __eq__(self, other):
18032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18033 
 
18034 
  def __ne__(self, other):
18035 
    return not (self == other)
18036 
 
18037 
class updateItemInventory_result:
18038 
  """
18039 
  Attributes:
18040 
   - success
18041 
  """
18042 
 
18043 
  thrift_spec = (
18044 
    (0, TType.BOOL, 'success', None, None, ), # 0
18045 
  )
18046 
 
18047 
  def __init__(self, success=None,):
18048 
    self.success = success
18049 
 
18050 
  def read(self, iprot):
18051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18053 
      return
18054 
    iprot.readStructBegin()
18055 
    while True:
18056 
      (fname, ftype, fid) = iprot.readFieldBegin()
18057 
      if ftype == TType.STOP:
18058 
        break
18059 
      if fid == 0:
18060 
        if ftype == TType.BOOL:
18061 
          self.success = iprot.readBool();
18062 
        else:
18063 
          iprot.skip(ftype)
18064 
      else:
18065 
        iprot.skip(ftype)
18066 
      iprot.readFieldEnd()
18067 
    iprot.readStructEnd()
18068 
 
18069 
  def write(self, oprot):
18070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18072 
      return
18073 
    oprot.writeStructBegin('updateItemInventory_result')
18074 
    if self.success is not None:
18075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18076 
      oprot.writeBool(self.success)
18077 
      oprot.writeFieldEnd()
18078 
    oprot.writeFieldStop()
18079 
    oprot.writeStructEnd()
18080 
 
18081 
  def validate(self):
18082 
    return
18083 
 
18084 
 
18085 
  def __repr__(self):
18086 
    L = ['%s=%r' % (key, value)
18087 
      for key, value in self.__dict__.iteritems()]
18088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18089 
 
18090 
  def __eq__(self, other):
18091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18092 
 
18093 
  def __ne__(self, other):
18094 
    return not (self == other)
7770 kshitij.so 18095 
 
18096 
class updateTimestampForAmazonFeeds_args:
18097 
  """
18098 
  Attributes:
18099 
   - type
18100 
   - sku
18101 
   - timestamp
18102 
  """
18103 
 
18104 
  thrift_spec = (
18105 
    None, # 0
18106 
    (1, TType.STRING, 'type', None, None, ), # 1
18107 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18108 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18109 
  )
18110 
 
18111 
  def __init__(self, type=None, sku=None, timestamp=None,):
18112 
    self.type = type
18113 
    self.sku = sku
18114 
    self.timestamp = timestamp
18115 
 
18116 
  def read(self, iprot):
18117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18119 
      return
18120 
    iprot.readStructBegin()
18121 
    while True:
18122 
      (fname, ftype, fid) = iprot.readFieldBegin()
18123 
      if ftype == TType.STOP:
18124 
        break
18125 
      if fid == 1:
18126 
        if ftype == TType.STRING:
18127 
          self.type = iprot.readString();
18128 
        else:
18129 
          iprot.skip(ftype)
18130 
      elif fid == 2:
18131 
        if ftype == TType.LIST:
18132 
          self.sku = []
18133 
          (_etype368, _size365) = iprot.readListBegin()
18134 
          for _i369 in xrange(_size365):
18135 
            _elem370 = iprot.readI64();
18136 
            self.sku.append(_elem370)
18137 
          iprot.readListEnd()
18138 
        else:
18139 
          iprot.skip(ftype)
18140 
      elif fid == 3:
18141 
        if ftype == TType.I64:
18142 
          self.timestamp = iprot.readI64();
18143 
        else:
18144 
          iprot.skip(ftype)
18145 
      else:
18146 
        iprot.skip(ftype)
18147 
      iprot.readFieldEnd()
18148 
    iprot.readStructEnd()
18149 
 
18150 
  def write(self, oprot):
18151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18153 
      return
18154 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18155 
    if self.type is not None:
18156 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18157 
      oprot.writeString(self.type)
18158 
      oprot.writeFieldEnd()
18159 
    if self.sku is not None:
18160 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18161 
      oprot.writeListBegin(TType.I64, len(self.sku))
18162 
      for iter371 in self.sku:
18163 
        oprot.writeI64(iter371)
18164 
      oprot.writeListEnd()
18165 
      oprot.writeFieldEnd()
18166 
    if self.timestamp is not None:
18167 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18168 
      oprot.writeI64(self.timestamp)
18169 
      oprot.writeFieldEnd()
18170 
    oprot.writeFieldStop()
18171 
    oprot.writeStructEnd()
18172 
 
18173 
  def validate(self):
18174 
    return
18175 
 
18176 
 
18177 
  def __repr__(self):
18178 
    L = ['%s=%r' % (key, value)
18179 
      for key, value in self.__dict__.iteritems()]
18180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18181 
 
18182 
  def __eq__(self, other):
18183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18184 
 
18185 
  def __ne__(self, other):
18186 
    return not (self == other)
18187 
 
18188 
class updateTimestampForAmazonFeeds_result:
18189 
  """
18190 
  Attributes:
18191 
   - success
18192 
  """
18193 
 
18194 
  thrift_spec = (
18195 
    (0, TType.BOOL, 'success', None, None, ), # 0
18196 
  )
18197 
 
18198 
  def __init__(self, success=None,):
18199 
    self.success = success
18200 
 
18201 
  def read(self, iprot):
18202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18204 
      return
18205 
    iprot.readStructBegin()
18206 
    while True:
18207 
      (fname, ftype, fid) = iprot.readFieldBegin()
18208 
      if ftype == TType.STOP:
18209 
        break
18210 
      if fid == 0:
18211 
        if ftype == TType.BOOL:
18212 
          self.success = iprot.readBool();
18213 
        else:
18214 
          iprot.skip(ftype)
18215 
      else:
18216 
        iprot.skip(ftype)
18217 
      iprot.readFieldEnd()
18218 
    iprot.readStructEnd()
18219 
 
18220 
  def write(self, oprot):
18221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18223 
      return
18224 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18225 
    if self.success is not None:
18226 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18227 
      oprot.writeBool(self.success)
18228 
      oprot.writeFieldEnd()
18229 
    oprot.writeFieldStop()
18230 
    oprot.writeStructEnd()
18231 
 
18232 
  def validate(self):
18233 
    return
18234 
 
18235 
 
18236 
  def __repr__(self):
18237 
    L = ['%s=%r' % (key, value)
18238 
      for key, value in self.__dict__.iteritems()]
18239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18240 
 
18241 
  def __eq__(self, other):
18242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18243 
 
18244 
  def __ne__(self, other):
18245 
    return not (self == other)
7897 amar.kumar 18246 
 
18247 
class getAllParentCategories_args:
18248 
 
18249 
  thrift_spec = (
18250 
  )
18251 
 
18252 
  def read(self, iprot):
18253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18255 
      return
18256 
    iprot.readStructBegin()
18257 
    while True:
18258 
      (fname, ftype, fid) = iprot.readFieldBegin()
18259 
      if ftype == TType.STOP:
18260 
        break
18261 
      else:
18262 
        iprot.skip(ftype)
18263 
      iprot.readFieldEnd()
18264 
    iprot.readStructEnd()
18265 
 
18266 
  def write(self, oprot):
18267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18269 
      return
18270 
    oprot.writeStructBegin('getAllParentCategories_args')
18271 
    oprot.writeFieldStop()
18272 
    oprot.writeStructEnd()
18273 
 
18274 
  def validate(self):
18275 
    return
18276 
 
18277 
 
18278 
  def __repr__(self):
18279 
    L = ['%s=%r' % (key, value)
18280 
      for key, value in self.__dict__.iteritems()]
18281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18282 
 
18283 
  def __eq__(self, other):
18284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18285 
 
18286 
  def __ne__(self, other):
18287 
    return not (self == other)
18288 
 
18289 
class getAllParentCategories_result:
18290 
  """
18291 
  Attributes:
18292 
   - success
18293 
  """
18294 
 
18295 
  thrift_spec = (
18296 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
18297 
  )
18298 
 
18299 
  def __init__(self, success=None,):
18300 
    self.success = success
18301 
 
18302 
  def read(self, iprot):
18303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18305 
      return
18306 
    iprot.readStructBegin()
18307 
    while True:
18308 
      (fname, ftype, fid) = iprot.readFieldBegin()
18309 
      if ftype == TType.STOP:
18310 
        break
18311 
      if fid == 0:
18312 
        if ftype == TType.LIST:
18313 
          self.success = []
18314 
          (_etype375, _size372) = iprot.readListBegin()
18315 
          for _i376 in xrange(_size372):
18316 
            _elem377 = Category()
18317 
            _elem377.read(iprot)
18318 
            self.success.append(_elem377)
18319 
          iprot.readListEnd()
18320 
        else:
18321 
          iprot.skip(ftype)
18322 
      else:
18323 
        iprot.skip(ftype)
18324 
      iprot.readFieldEnd()
18325 
    iprot.readStructEnd()
18326 
 
18327 
  def write(self, oprot):
18328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18330 
      return
18331 
    oprot.writeStructBegin('getAllParentCategories_result')
18332 
    if self.success is not None:
18333 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18334 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18335 
      for iter378 in self.success:
18336 
        iter378.write(oprot)
18337 
      oprot.writeListEnd()
18338 
      oprot.writeFieldEnd()
18339 
    oprot.writeFieldStop()
18340 
    oprot.writeStructEnd()
18341 
 
18342 
  def validate(self):
18343 
    return
18344 
 
18345 
 
18346 
  def __repr__(self):
18347 
    L = ['%s=%r' % (key, value)
18348 
      for key, value in self.__dict__.iteritems()]
18349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18350 
 
18351 
  def __eq__(self, other):
18352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18353 
 
18354 
  def __ne__(self, other):
18355 
    return not (self == other)