Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
6850 kshitij.so 316 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
317 
    """
318 
    Parameters:
319 
     - bannerName
320 
     - imageName
321 
     - link
322 
     - priority
323 
     - isActive
324 
     - hasMap
325 
    """
326 
    pass
327 
 
328 
  def getAllBanners(self, ):
329 
    pass
330 
 
331 
  def deleteBanner(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getBannerDetails(self, bannerName):
339 
    """
340 
    Parameters:
341 
     - bannerName
342 
    """
343 
    pass
344 
 
345 
  def getActiveBanners(self, ):
346 
    pass
347 
 
6849 kshitij.so 348 
  def addBannerMap(self, bannerName, mapLink, coordinates):
349 
    """
350 
    Parameters:
351 
     - bannerName
352 
     - mapLink
353 
     - coordinates
354 
    """
355 
    pass
356 
 
357 
  def deleteBannerMap(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
364 
  def getBannerMapDetails(self, bannerName):
365 
    """
366 
    Parameters:
367 
     - bannerName
368 
    """
369 
    pass
370 
 
5944 mandeep.dh 371 
  def deleteSimilarItem(self, itemId, catalogItemId):
372 
    """
373 
    Delete similar item.
374 
 
375 
    Parameters:
376 
     - itemId
377 
     - catalogItemId
378 
    """
379 
    pass
380 
 
381 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
382 
    """
383 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
384 
    If yes, returns the itemId else returns 0
385 
 
386 
    Parameters:
387 
     - brand
388 
     - modelNumber
389 
     - modelName
390 
     - color
391 
    """
392 
    pass
393 
 
394 
  def validateRiskyStatus(self, itemId):
395 
    """
396 
    Check wether item is risky and change status if inventory is not available for risky items
397 
 
398 
    Parameters:
399 
     - itemId
400 
    """
401 
    pass
402 
 
403 
  def changeItemRiskyFlag(self, itemId, risky):
404 
    """
405 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
406 
 
407 
    Parameters:
408 
     - itemId
409 
     - risky
410 
    """
411 
    pass
412 
 
413 
  def getItemsByRiskyFlag(self, ):
414 
    """
415 
    Returns list of items marked as risky.
416 
    """
417 
    pass
418 
 
419 
  def getItemsForMasterSheet(self, category, brand):
420 
    """
421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
422 
 
423 
    Parameters:
424 
     - category
425 
     - brand
426 
    """
427 
    pass
428 
 
429 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
430 
    """
431 
    Returns list of catalog ids of items with same similarity index as of the given itemId
432 
 
433 
    Parameters:
434 
     - beginIndex
435 
     - totalItems
436 
     - itemId
437 
    """
438 
    pass
439 
 
440 
  def addProductNotification(self, itemId, email):
441 
    """
442 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
443 
 
444 
    Parameters:
445 
     - itemId
446 
     - email
447 
    """
448 
    pass
449 
 
450 
  def sendProductNotifications(self, ):
451 
    """
452 
    Send the product notifications to the users for items which has stock.
453 
    """
454 
    pass
455 
 
456 
  def getAllBrandsByCategory(self, categoryId):
457 
    """
458 
    Returns list of brand names for a given category Id
459 
 
460 
    Parameters:
461 
     - categoryId
462 
    """
463 
    pass
464 
 
465 
  def getAllBrands(self, ):
466 
    """
467 
    Returns list of brand names
468 
    """
469 
    pass
470 
 
471 
  def getAllSources(self, ):
472 
    """
473 
    Return list of all sources
474 
    """
475 
    pass
476 
 
477 
  def getItemPricingBySource(self, itemId, sourceId):
478 
    """
479 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
480 
 
481 
    Parameters:
482 
     - itemId
483 
     - sourceId
484 
    """
485 
    pass
486 
 
487 
  def addSourceItemPricing(self, sourceItemPricing):
488 
    """
489 
    Adds prices to be displayed corresponding to the item if user comes from a source.
490 
    If item is not found or source is not found, it will throw exception.
491 
 
492 
    Parameters:
493 
     - sourceItemPricing
494 
    """
495 
    pass
496 
 
497 
  def getAllSourcePricing(self, itemId):
498 
    """
499 
    Returns the list of source pricing information of an item.
500 
    Raises an exception if item not found corresponding to itemId
501 
 
502 
    Parameters:
503 
     - itemId
504 
    """
505 
    pass
506 
 
507 
  def getItemForSource(self, item_id, sourceId):
508 
    """
509 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
510 
 
511 
    Parameters:
512 
     - item_id
513 
     - sourceId
514 
    """
515 
    pass
516 
 
517 
  def searchItemsInRange(self, searchTerms, offset, limit):
518 
    """
519 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
520 
 
521 
    Parameters:
522 
     - searchTerms
523 
     - offset
524 
     - limit
525 
    """
526 
    pass
527 
 
528 
  def getSearchResultCount(self, searchTerms):
529 
    """
530 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
531 
 
532 
    Parameters:
533 
     - searchTerms
534 
    """
535 
    pass
536 
 
537 
  def getProductNotifications(self, startDateTime):
538 
    """
539 
    Returns a list of product notifications added after a supplied datetime
540 
 
541 
    Parameters:
542 
     - startDateTime
543 
    """
544 
    pass
545 
 
7897 amar.kumar 546 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 547 
    """
548 
    Returns a list of count of requests for product notification against each item
549 
 
550 
    Parameters:
551 
     - startDateTime
7897 amar.kumar 552 
     - categoryId
5944 mandeep.dh 553 
    """
554 
    pass
555 
 
556 
  def addAuthorizationLog(self, itemId, username, reason):
557 
    """
558 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
559 
 
560 
    Parameters:
561 
     - itemId
562 
     - username
563 
     - reason
564 
    """
565 
    pass
566 
 
567 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
568 
    """
569 
    Parameters:
570 
     - catalog_item_id
571 
     - voucherType
572 
     - voucherAmount
573 
    """
574 
    pass
575 
 
576 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
577 
    """
578 
    Parameters:
579 
     - catalog_item_id
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getVoucherAmount(self, itemId, voucherType):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
     - voucherType
589 
    """
590 
    pass
591 
 
592 
  def getAllItemVouchers(self, itemId):
593 
    """
594 
    Parameters:
595 
     - itemId
596 
    """
597 
    pass
598 
 
599 
  def isValidCatalogItemId(self, catalog_item_id):
600 
    """
601 
    Parameters:
602 
     - catalog_item_id
603 
    """
604 
    pass
605 
 
7330 amit.gupta 606 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 607 
    """
608 
    Parameters:
609 
     - itemId
7330 amit.gupta 610 
     - stateId
6039 amit.gupta 611 
     - price
612 
    """
613 
    pass
5944 mandeep.dh 614 
 
6039 amit.gupta 615 
  def getVatAmountForItem(self, itemId, price):
616 
    """
617 
    Parameters:
618 
     - itemId
619 
     - price
620 
    """
621 
    pass
622 
 
6531 vikram.rag 623 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
624 
    """
625 
    Parameters:
626 
     - offset
627 
     - limit
628 
    """
629 
    pass
6039 amit.gupta 630 
 
6821 amar.kumar 631 
  def getAllAliveItems(self, ):
632 
    pass
633 
 
6921 anupam.sin 634 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 635 
    """
636 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 637 
 
6805 anupam.sin 638 
    Parameters:
639 
     - itemId
6921 anupam.sin 640 
     - price
6805 anupam.sin 641 
     - insurerId
642 
     - quantity
643 
    """
644 
    pass
645 
 
646 
  def getInsurer(self, insurerId):
647 
    """
648 
    Parameters:
649 
     - insurerId
650 
    """
651 
    pass
652 
 
6838 vikram.rag 653 
  def getAllInsurers(self, ):
654 
    pass
6805 anupam.sin 655 
 
6962 rajveer 656 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
657 
    """
658 
    Parameters:
659 
     - insurerId
660 
     - amount
661 
    """
662 
    pass
6838 vikram.rag 663 
 
7190 amar.kumar 664 
  def getFreebieForItem(self, itemId):
665 
    """
666 
    Parameters:
667 
     - itemId
668 
    """
669 
    pass
6962 rajveer 670 
 
7190 amar.kumar 671 
  def addOrUpdateFreebieForItem(self, freebieItem):
672 
    """
673 
    Parameters:
674 
     - freebieItem
675 
    """
676 
    pass
677 
 
7272 amit.gupta 678 
  def addOrUpdateBrandInfo(self, brandInfo):
679 
    """
680 
    Parameters:
681 
     - brandInfo
682 
    """
683 
    pass
684 
 
685 
  def getBrandInfo(self, ):
686 
    pass
687 
 
7256 rajveer 688 
  def getStorePricing(self, itemId):
689 
    """
690 
    Parameters:
691 
     - itemId
692 
    """
693 
    pass
7190 amar.kumar 694 
 
7306 rajveer 695 
  def getStorePricings(self, itemIds):
696 
    """
697 
    Parameters:
698 
     - itemIds
699 
    """
700 
    pass
701 
 
7382 rajveer 702 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 703 
    """
704 
    Parameters:
705 
     - sp
7382 rajveer 706 
     - allColors
7265 rajveer 707 
    """
708 
    pass
7256 rajveer 709 
 
7281 kshitij.so 710 
  def getAllAmazonListedItems(self, ):
711 
    pass
7265 rajveer 712 
 
7281 kshitij.so 713 
  def getAmazonItemDetails(self, itemId):
714 
    """
715 
    Parameters:
716 
     - itemId
717 
    """
718 
    pass
719 
 
8168 kshitij.so 720 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 721 
    """
722 
    Parameters:
8168 kshitij.so 723 
     - amazonlisted
7281 kshitij.so 724 
    """
725 
    pass
726 
 
727 
  def addAmazonItem(self, amazonlisted):
728 
    """
729 
    Parameters:
730 
     - amazonlisted
731 
    """
732 
    pass
733 
 
7291 vikram.rag 734 
  def getAsinItems(self, ):
735 
    pass
7281 kshitij.so 736 
 
7291 vikram.rag 737 
  def getAllFbaListedItems(self, ):
738 
    pass
739 
 
740 
  def getAllNonFbaListedItems(self, ):
741 
    pass
742 
 
7460 kshitij.so 743 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
     - holdInventory
748 
     - defaultInventory
749 
    """
750 
    pass
7291 vikram.rag 751 
 
7770 kshitij.so 752 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
753 
    """
754 
    Parameters:
755 
     - type
756 
     - sku
757 
     - timestamp
758 
    """
759 
    pass
7460 kshitij.so 760 
 
7897 amar.kumar 761 
  def getAllParentCategories(self, ):
762 
    pass
7770 kshitij.so 763 
 
7977 kshitij.so 764 
  def addPageViewEvent(self, pageViewEvents):
765 
    """
766 
    Parameters:
767 
     - pageViewEvents
768 
    """
769 
    pass
7897 amar.kumar 770 
 
7977 kshitij.so 771 
  def addCartEvent(self, cartEvents):
772 
    """
773 
    Parameters:
774 
     - cartEvents
775 
    """
776 
    pass
777 
 
8182 amar.kumar 778 
  def addEbayItem(self, ebayItem):
779 
    """
780 
    Parameters:
781 
     - ebayItem
782 
    """
783 
    pass
784 
 
785 
  def getEbayItem(self, listingId):
786 
    """
787 
    Parameters:
788 
     - listingId
789 
    """
790 
    pass
791 
 
792 
  def updateEbayItem(self, ebayItem):
793 
    """
794 
    Parameters:
795 
     - ebayItem
796 
    """
797 
    pass
798 
 
8139 kshitij.so 799 
  def getAmazonListedItems(self, offset, limit):
800 
    """
801 
    Parameters:
802 
     - offset
803 
     - limit
804 
    """
805 
    pass
7977 kshitij.so 806 
 
8168 kshitij.so 807 
  def updateAmazonAttributesInBulk(self, amazonlisted):
808 
    """
809 
    Parameters:
810 
     - amazonlisted
811 
    """
812 
    pass
8139 kshitij.so 813 
 
8168 kshitij.so 814 
 
5944 mandeep.dh 815 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
816 
  def __init__(self, iprot, oprot=None):
817 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
818 
 
819 
  def addItem(self, item):
820 
    """
821 
    Availability and inventory attributes
822 
 
823 
    Parameters:
824 
     - item
825 
    """
826 
    self.send_addItem(item)
827 
    return self.recv_addItem()
828 
 
829 
  def send_addItem(self, item):
830 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
831 
    args = addItem_args()
832 
    args.item = item
833 
    args.write(self._oprot)
834 
    self._oprot.writeMessageEnd()
835 
    self._oprot.trans.flush()
836 
 
837 
  def recv_addItem(self, ):
838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
839 
    if mtype == TMessageType.EXCEPTION:
840 
      x = TApplicationException()
841 
      x.read(self._iprot)
842 
      self._iprot.readMessageEnd()
843 
      raise x
844 
    result = addItem_result()
845 
    result.read(self._iprot)
846 
    self._iprot.readMessageEnd()
847 
    if result.success is not None:
848 
      return result.success
849 
    if result.cex is not None:
850 
      raise result.cex
851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
852 
 
853 
  def updateItem(self, item):
854 
    """
855 
    Parameters:
856 
     - item
857 
    """
858 
    self.send_updateItem(item)
859 
    return self.recv_updateItem()
860 
 
861 
  def send_updateItem(self, item):
862 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
863 
    args = updateItem_args()
864 
    args.item = item
865 
    args.write(self._oprot)
866 
    self._oprot.writeMessageEnd()
867 
    self._oprot.trans.flush()
868 
 
869 
  def recv_updateItem(self, ):
870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
871 
    if mtype == TMessageType.EXCEPTION:
872 
      x = TApplicationException()
873 
      x.read(self._iprot)
874 
      self._iprot.readMessageEnd()
875 
      raise x
876 
    result = updateItem_result()
877 
    result.read(self._iprot)
878 
    self._iprot.readMessageEnd()
879 
    if result.success is not None:
880 
      return result.success
881 
    if result.cex is not None:
882 
      raise result.cex
883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
884 
 
885 
  def isActive(self, itemId):
886 
    """
887 
    Checks if the item given to the corresponding itemId is active. If it's active,
888 
    whether it's risky and if it's risky, its inventory position.
889 
 
890 
    Parameters:
891 
     - itemId
892 
    """
893 
    self.send_isActive(itemId)
894 
    return self.recv_isActive()
895 
 
896 
  def send_isActive(self, itemId):
897 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
898 
    args = isActive_args()
899 
    args.itemId = itemId
900 
    args.write(self._oprot)
901 
    self._oprot.writeMessageEnd()
902 
    self._oprot.trans.flush()
903 
 
904 
  def recv_isActive(self, ):
905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
906 
    if mtype == TMessageType.EXCEPTION:
907 
      x = TApplicationException()
908 
      x.read(self._iprot)
909 
      self._iprot.readMessageEnd()
910 
      raise x
911 
    result = isActive_result()
912 
    result.read(self._iprot)
913 
    self._iprot.readMessageEnd()
914 
    if result.success is not None:
915 
      return result.success
916 
    if result.isex is not None:
917 
      raise result.isex
918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
919 
 
7438 amit.gupta 920 
  def getItemsStatus(self, itemIds):
921 
    """
922 
    Parameters:
923 
     - itemIds
924 
    """
925 
    self.send_getItemsStatus(itemIds)
926 
    return self.recv_getItemsStatus()
927 
 
928 
  def send_getItemsStatus(self, itemIds):
929 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
930 
    args = getItemsStatus_args()
931 
    args.itemIds = itemIds
932 
    args.write(self._oprot)
933 
    self._oprot.writeMessageEnd()
934 
    self._oprot.trans.flush()
935 
 
936 
  def recv_getItemsStatus(self, ):
937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
938 
    if mtype == TMessageType.EXCEPTION:
939 
      x = TApplicationException()
940 
      x.read(self._iprot)
941 
      self._iprot.readMessageEnd()
942 
      raise x
943 
    result = getItemsStatus_result()
944 
    result.read(self._iprot)
945 
    self._iprot.readMessageEnd()
946 
    if result.success is not None:
947 
      return result.success
948 
    if result.isex is not None:
949 
      raise result.isex
950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
951 
 
5944 mandeep.dh 952 
  def getItemStatusDescription(self, itemId):
953 
    """
954 
    Parameters:
955 
     - itemId
956 
    """
957 
    self.send_getItemStatusDescription(itemId)
958 
    return self.recv_getItemStatusDescription()
959 
 
960 
  def send_getItemStatusDescription(self, itemId):
961 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
962 
    args = getItemStatusDescription_args()
963 
    args.itemId = itemId
964 
    args.write(self._oprot)
965 
    self._oprot.writeMessageEnd()
966 
    self._oprot.trans.flush()
967 
 
968 
  def recv_getItemStatusDescription(self, ):
969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
970 
    if mtype == TMessageType.EXCEPTION:
971 
      x = TApplicationException()
972 
      x.read(self._iprot)
973 
      self._iprot.readMessageEnd()
974 
      raise x
975 
    result = getItemStatusDescription_result()
976 
    result.read(self._iprot)
977 
    self._iprot.readMessageEnd()
978 
    if result.success is not None:
979 
      return result.success
980 
    if result.isex is not None:
981 
      raise result.isex
982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
983 
 
984 
  def startItemOn(self, item_id, timestamp):
985 
    """
986 
    Parameters:
987 
     - item_id
988 
     - timestamp
989 
    """
990 
    self.send_startItemOn(item_id, timestamp)
991 
    self.recv_startItemOn()
992 
 
993 
  def send_startItemOn(self, item_id, timestamp):
994 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
995 
    args = startItemOn_args()
996 
    args.item_id = item_id
997 
    args.timestamp = timestamp
998 
    args.write(self._oprot)
999 
    self._oprot.writeMessageEnd()
1000 
    self._oprot.trans.flush()
1001 
 
1002 
  def recv_startItemOn(self, ):
1003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1004 
    if mtype == TMessageType.EXCEPTION:
1005 
      x = TApplicationException()
1006 
      x.read(self._iprot)
1007 
      self._iprot.readMessageEnd()
1008 
      raise x
1009 
    result = startItemOn_result()
1010 
    result.read(self._iprot)
1011 
    self._iprot.readMessageEnd()
1012 
    if result.cex is not None:
1013 
      raise result.cex
1014 
    return
1015 
 
1016 
  def retireItemOn(self, item_id, timestamp):
1017 
    """
1018 
    Parameters:
1019 
     - item_id
1020 
     - timestamp
1021 
    """
1022 
    self.send_retireItemOn(item_id, timestamp)
1023 
    self.recv_retireItemOn()
1024 
 
1025 
  def send_retireItemOn(self, item_id, timestamp):
1026 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1027 
    args = retireItemOn_args()
1028 
    args.item_id = item_id
1029 
    args.timestamp = timestamp
1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
1034 
  def recv_retireItemOn(self, ):
1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
1041 
    result = retireItemOn_result()
1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
1044 
    if result.cex is not None:
1045 
      raise result.cex
1046 
    return
1047 
 
1048 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1049 
    """
1050 
    Parameters:
1051 
     - item_id
1052 
     - timestamp
1053 
     - newstatus
1054 
    """
1055 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1056 
    self.recv_changeItemStatus()
1057 
 
1058 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1059 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1060 
    args = changeItemStatus_args()
1061 
    args.item_id = item_id
1062 
    args.timestamp = timestamp
1063 
    args.newstatus = newstatus
1064 
    args.write(self._oprot)
1065 
    self._oprot.writeMessageEnd()
1066 
    self._oprot.trans.flush()
1067 
 
1068 
  def recv_changeItemStatus(self, ):
1069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1070 
    if mtype == TMessageType.EXCEPTION:
1071 
      x = TApplicationException()
1072 
      x.read(self._iprot)
1073 
      self._iprot.readMessageEnd()
1074 
      raise x
1075 
    result = changeItemStatus_result()
1076 
    result.read(self._iprot)
1077 
    self._iprot.readMessageEnd()
1078 
    if result.cex is not None:
1079 
      raise result.cex
1080 
    return
1081 
 
1082 
  def getItem(self, item_id):
1083 
    """
1084 
    Parameters:
1085 
     - item_id
1086 
    """
1087 
    self.send_getItem(item_id)
1088 
    return self.recv_getItem()
1089 
 
1090 
  def send_getItem(self, item_id):
1091 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1092 
    args = getItem_args()
1093 
    args.item_id = item_id
1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1098 
  def recv_getItem(self, ):
1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1105 
    result = getItem_result()
1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
1108 
    if result.success is not None:
1109 
      return result.success
1110 
    if result.cex is not None:
1111 
      raise result.cex
1112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1113 
 
1114 
  def getItemsByCatalogId(self, catalog_item_id):
1115 
    """
1116 
    Parameters:
1117 
     - catalog_item_id
1118 
    """
1119 
    self.send_getItemsByCatalogId(catalog_item_id)
1120 
    return self.recv_getItemsByCatalogId()
1121 
 
1122 
  def send_getItemsByCatalogId(self, catalog_item_id):
1123 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1124 
    args = getItemsByCatalogId_args()
1125 
    args.catalog_item_id = catalog_item_id
1126 
    args.write(self._oprot)
1127 
    self._oprot.writeMessageEnd()
1128 
    self._oprot.trans.flush()
1129 
 
1130 
  def recv_getItemsByCatalogId(self, ):
1131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1132 
    if mtype == TMessageType.EXCEPTION:
1133 
      x = TApplicationException()
1134 
      x.read(self._iprot)
1135 
      self._iprot.readMessageEnd()
1136 
      raise x
1137 
    result = getItemsByCatalogId_result()
1138 
    result.read(self._iprot)
1139 
    self._iprot.readMessageEnd()
1140 
    if result.success is not None:
1141 
      return result.success
1142 
    if result.cex is not None:
1143 
      raise result.cex
1144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1145 
 
1146 
  def getValidItemsByCatalogId(self, catalog_item_id):
1147 
    """
1148 
    Parameters:
1149 
     - catalog_item_id
1150 
    """
1151 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1152 
    return self.recv_getValidItemsByCatalogId()
1153 
 
1154 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1155 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1156 
    args = getValidItemsByCatalogId_args()
1157 
    args.catalog_item_id = catalog_item_id
1158 
    args.write(self._oprot)
1159 
    self._oprot.writeMessageEnd()
1160 
    self._oprot.trans.flush()
1161 
 
1162 
  def recv_getValidItemsByCatalogId(self, ):
1163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1164 
    if mtype == TMessageType.EXCEPTION:
1165 
      x = TApplicationException()
1166 
      x.read(self._iprot)
1167 
      self._iprot.readMessageEnd()
1168 
      raise x
1169 
    result = getValidItemsByCatalogId_result()
1170 
    result.read(self._iprot)
1171 
    self._iprot.readMessageEnd()
1172 
    if result.success is not None:
1173 
      return result.success
1174 
    if result.cex is not None:
1175 
      raise result.cex
1176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1177 
 
1178 
  def getAllItems(self, isActive):
1179 
    """
1180 
    Parameters:
1181 
     - isActive
1182 
    """
1183 
    self.send_getAllItems(isActive)
1184 
    return self.recv_getAllItems()
1185 
 
1186 
  def send_getAllItems(self, isActive):
1187 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1188 
    args = getAllItems_args()
1189 
    args.isActive = isActive
1190 
    args.write(self._oprot)
1191 
    self._oprot.writeMessageEnd()
1192 
    self._oprot.trans.flush()
1193 
 
1194 
  def recv_getAllItems(self, ):
1195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1196 
    if mtype == TMessageType.EXCEPTION:
1197 
      x = TApplicationException()
1198 
      x.read(self._iprot)
1199 
      self._iprot.readMessageEnd()
1200 
      raise x
1201 
    result = getAllItems_result()
1202 
    result.read(self._iprot)
1203 
    self._iprot.readMessageEnd()
1204 
    if result.success is not None:
1205 
      return result.success
1206 
    if result.cex is not None:
1207 
      raise result.cex
1208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1209 
 
1210 
  def getAllItemsByStatus(self, itemStatus):
1211 
    """
1212 
    Parameters:
1213 
     - itemStatus
1214 
    """
1215 
    self.send_getAllItemsByStatus(itemStatus)
1216 
    return self.recv_getAllItemsByStatus()
1217 
 
1218 
  def send_getAllItemsByStatus(self, itemStatus):
1219 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1220 
    args = getAllItemsByStatus_args()
1221 
    args.itemStatus = itemStatus
1222 
    args.write(self._oprot)
1223 
    self._oprot.writeMessageEnd()
1224 
    self._oprot.trans.flush()
1225 
 
1226 
  def recv_getAllItemsByStatus(self, ):
1227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1228 
    if mtype == TMessageType.EXCEPTION:
1229 
      x = TApplicationException()
1230 
      x.read(self._iprot)
1231 
      self._iprot.readMessageEnd()
1232 
      raise x
1233 
    result = getAllItemsByStatus_result()
1234 
    result.read(self._iprot)
1235 
    self._iprot.readMessageEnd()
1236 
    if result.success is not None:
1237 
      return result.success
1238 
    if result.cex is not None:
1239 
      raise result.cex
1240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1241 
 
1242 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1243 
    """
1244 
    Parameters:
1245 
     - entityId
1246 
     - category
1247 
     - brand
1248 
     - modelName
1249 
     - modelNumber
1250 
    """
1251 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1252 
    return self.recv_markItemAsContentComplete()
1253 
 
1254 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1255 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1256 
    args = markItemAsContentComplete_args()
1257 
    args.entityId = entityId
1258 
    args.category = category
1259 
    args.brand = brand
1260 
    args.modelName = modelName
1261 
    args.modelNumber = modelNumber
1262 
    args.write(self._oprot)
1263 
    self._oprot.writeMessageEnd()
1264 
    self._oprot.trans.flush()
1265 
 
1266 
  def recv_markItemAsContentComplete(self, ):
1267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1268 
    if mtype == TMessageType.EXCEPTION:
1269 
      x = TApplicationException()
1270 
      x.read(self._iprot)
1271 
      self._iprot.readMessageEnd()
1272 
      raise x
1273 
    result = markItemAsContentComplete_result()
1274 
    result.read(self._iprot)
1275 
    self._iprot.readMessageEnd()
1276 
    if result.success is not None:
1277 
      return result.success
1278 
    if result.cex is not None:
1279 
      raise result.cex
1280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1281 
 
1282 
  def getAllItemsInRange(self, offset, limit):
1283 
    """
1284 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1285 
 
1286 
    Parameters:
1287 
     - offset
1288 
     - limit
1289 
    """
1290 
    self.send_getAllItemsInRange(offset, limit)
1291 
    return self.recv_getAllItemsInRange()
1292 
 
1293 
  def send_getAllItemsInRange(self, offset, limit):
1294 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1295 
    args = getAllItemsInRange_args()
1296 
    args.offset = offset
1297 
    args.limit = limit
1298 
    args.write(self._oprot)
1299 
    self._oprot.writeMessageEnd()
1300 
    self._oprot.trans.flush()
1301 
 
1302 
  def recv_getAllItemsInRange(self, ):
1303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1304 
    if mtype == TMessageType.EXCEPTION:
1305 
      x = TApplicationException()
1306 
      x.read(self._iprot)
1307 
      self._iprot.readMessageEnd()
1308 
      raise x
1309 
    result = getAllItemsInRange_result()
1310 
    result.read(self._iprot)
1311 
    self._iprot.readMessageEnd()
1312 
    if result.success is not None:
1313 
      return result.success
1314 
    if result.cex is not None:
1315 
      raise result.cex
1316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1317 
 
1318 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1319 
    """
1320 
    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.
1321 
 
1322 
    Parameters:
1323 
     - itemStatus
1324 
     - offset
1325 
     - limit
1326 
    """
1327 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1328 
    return self.recv_getAllItemsByStatusInRange()
1329 
 
1330 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1331 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1332 
    args = getAllItemsByStatusInRange_args()
1333 
    args.itemStatus = itemStatus
1334 
    args.offset = offset
1335 
    args.limit = limit
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getAllItemsByStatusInRange(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getAllItemsByStatusInRange_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.success is not None:
1351 
      return result.success
1352 
    if result.cex is not None:
1353 
      raise result.cex
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1355 
 
1356 
  def getItemCountByStatus(self, useStatus, itemStatus):
1357 
    """
1358 
    Gets a count of all items by status
1359 
 
1360 
    Parameters:
1361 
     - useStatus
1362 
     - itemStatus
1363 
    """
1364 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1365 
    return self.recv_getItemCountByStatus()
1366 
 
1367 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1368 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1369 
    args = getItemCountByStatus_args()
1370 
    args.useStatus = useStatus
1371 
    args.itemStatus = itemStatus
1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
1376 
  def recv_getItemCountByStatus(self, ):
1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
1383 
    result = getItemCountByStatus_result()
1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
1386 
    if result.success is not None:
1387 
      return result.success
1388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1389 
 
1390 
  def getBestSellers(self, ):
1391 
    self.send_getBestSellers()
1392 
    return self.recv_getBestSellers()
1393 
 
1394 
  def send_getBestSellers(self, ):
1395 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1396 
    args = getBestSellers_args()
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_getBestSellers(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = getBestSellers_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.success is not None:
1412 
      return result.success
1413 
    if result.isex is not None:
1414 
      raise result.isex
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1416 
 
1417 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1418 
    """
1419 
    Parameters:
1420 
     - beginIndex
1421 
     - totalItems
1422 
     - brand
1423 
     - category
1424 
    """
1425 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1426 
    return self.recv_getBestSellersCatalogIds()
1427 
 
1428 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1429 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1430 
    args = getBestSellersCatalogIds_args()
1431 
    args.beginIndex = beginIndex
1432 
    args.totalItems = totalItems
1433 
    args.brand = brand
1434 
    args.category = category
1435 
    args.write(self._oprot)
1436 
    self._oprot.writeMessageEnd()
1437 
    self._oprot.trans.flush()
1438 
 
1439 
  def recv_getBestSellersCatalogIds(self, ):
1440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1441 
    if mtype == TMessageType.EXCEPTION:
1442 
      x = TApplicationException()
1443 
      x.read(self._iprot)
1444 
      self._iprot.readMessageEnd()
1445 
      raise x
1446 
    result = getBestSellersCatalogIds_result()
1447 
    result.read(self._iprot)
1448 
    self._iprot.readMessageEnd()
1449 
    if result.success is not None:
1450 
      return result.success
1451 
    if result.cex is not None:
1452 
      raise result.cex
1453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1454 
 
1455 
  def getBestSellersCount(self, ):
1456 
    self.send_getBestSellersCount()
1457 
    return self.recv_getBestSellersCount()
1458 
 
1459 
  def send_getBestSellersCount(self, ):
1460 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1461 
    args = getBestSellersCount_args()
1462 
    args.write(self._oprot)
1463 
    self._oprot.writeMessageEnd()
1464 
    self._oprot.trans.flush()
1465 
 
1466 
  def recv_getBestSellersCount(self, ):
1467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1468 
    if mtype == TMessageType.EXCEPTION:
1469 
      x = TApplicationException()
1470 
      x.read(self._iprot)
1471 
      self._iprot.readMessageEnd()
1472 
      raise x
1473 
    result = getBestSellersCount_result()
1474 
    result.read(self._iprot)
1475 
    self._iprot.readMessageEnd()
1476 
    if result.success is not None:
1477 
      return result.success
1478 
    if result.cex is not None:
1479 
      raise result.cex
1480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1481 
 
1482 
  def getBestDeals(self, ):
1483 
    self.send_getBestDeals()
1484 
    return self.recv_getBestDeals()
1485 
 
1486 
  def send_getBestDeals(self, ):
1487 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1488 
    args = getBestDeals_args()
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_getBestDeals(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = getBestDeals_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
1503 
    if result.success is not None:
1504 
      return result.success
1505 
    if result.isex is not None:
1506 
      raise result.isex
1507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1508 
 
1509 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1510 
    """
1511 
    Parameters:
1512 
     - beginIndex
1513 
     - totalItems
1514 
     - brand
1515 
     - category
1516 
    """
1517 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1518 
    return self.recv_getBestDealsCatalogIds()
1519 
 
1520 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1521 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1522 
    args = getBestDealsCatalogIds_args()
1523 
    args.beginIndex = beginIndex
1524 
    args.totalItems = totalItems
1525 
    args.brand = brand
1526 
    args.category = category
1527 
    args.write(self._oprot)
1528 
    self._oprot.writeMessageEnd()
1529 
    self._oprot.trans.flush()
1530 
 
1531 
  def recv_getBestDealsCatalogIds(self, ):
1532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1533 
    if mtype == TMessageType.EXCEPTION:
1534 
      x = TApplicationException()
1535 
      x.read(self._iprot)
1536 
      self._iprot.readMessageEnd()
1537 
      raise x
1538 
    result = getBestDealsCatalogIds_result()
1539 
    result.read(self._iprot)
1540 
    self._iprot.readMessageEnd()
1541 
    if result.success is not None:
1542 
      return result.success
1543 
    if result.cex is not None:
1544 
      raise result.cex
1545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1546 
 
1547 
  def getBestDealsCount(self, ):
1548 
    self.send_getBestDealsCount()
1549 
    return self.recv_getBestDealsCount()
1550 
 
1551 
  def send_getBestDealsCount(self, ):
1552 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1553 
    args = getBestDealsCount_args()
1554 
    args.write(self._oprot)
1555 
    self._oprot.writeMessageEnd()
1556 
    self._oprot.trans.flush()
1557 
 
1558 
  def recv_getBestDealsCount(self, ):
1559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1560 
    if mtype == TMessageType.EXCEPTION:
1561 
      x = TApplicationException()
1562 
      x.read(self._iprot)
1563 
      self._iprot.readMessageEnd()
1564 
      raise x
1565 
    result = getBestDealsCount_result()
1566 
    result.read(self._iprot)
1567 
    self._iprot.readMessageEnd()
1568 
    if result.success is not None:
1569 
      return result.success
1570 
    if result.cex is not None:
1571 
      raise result.cex
1572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1573 
 
1574 
  def getComingSoon(self, ):
1575 
    self.send_getComingSoon()
1576 
    return self.recv_getComingSoon()
1577 
 
1578 
  def send_getComingSoon(self, ):
1579 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1580 
    args = getComingSoon_args()
1581 
    args.write(self._oprot)
1582 
    self._oprot.writeMessageEnd()
1583 
    self._oprot.trans.flush()
1584 
 
1585 
  def recv_getComingSoon(self, ):
1586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1587 
    if mtype == TMessageType.EXCEPTION:
1588 
      x = TApplicationException()
1589 
      x.read(self._iprot)
1590 
      self._iprot.readMessageEnd()
1591 
      raise x
1592 
    result = getComingSoon_result()
1593 
    result.read(self._iprot)
1594 
    self._iprot.readMessageEnd()
1595 
    if result.success is not None:
1596 
      return result.success
1597 
    if result.isex is not None:
1598 
      raise result.isex
1599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1600 
 
1601 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1602 
    """
1603 
    Parameters:
1604 
     - beginIndex
1605 
     - totalItems
1606 
     - brand
1607 
     - category
1608 
    """
1609 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1610 
    return self.recv_getComingSoonCatalogIds()
1611 
 
1612 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1613 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1614 
    args = getComingSoonCatalogIds_args()
1615 
    args.beginIndex = beginIndex
1616 
    args.totalItems = totalItems
1617 
    args.brand = brand
1618 
    args.category = category
1619 
    args.write(self._oprot)
1620 
    self._oprot.writeMessageEnd()
1621 
    self._oprot.trans.flush()
1622 
 
1623 
  def recv_getComingSoonCatalogIds(self, ):
1624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1625 
    if mtype == TMessageType.EXCEPTION:
1626 
      x = TApplicationException()
1627 
      x.read(self._iprot)
1628 
      self._iprot.readMessageEnd()
1629 
      raise x
1630 
    result = getComingSoonCatalogIds_result()
1631 
    result.read(self._iprot)
1632 
    self._iprot.readMessageEnd()
1633 
    if result.success is not None:
1634 
      return result.success
1635 
    if result.cex is not None:
1636 
      raise result.cex
1637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1638 
 
1639 
  def getComingSoonCount(self, ):
1640 
    self.send_getComingSoonCount()
1641 
    return self.recv_getComingSoonCount()
1642 
 
1643 
  def send_getComingSoonCount(self, ):
1644 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1645 
    args = getComingSoonCount_args()
1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
1650 
  def recv_getComingSoonCount(self, ):
1651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1652 
    if mtype == TMessageType.EXCEPTION:
1653 
      x = TApplicationException()
1654 
      x.read(self._iprot)
1655 
      self._iprot.readMessageEnd()
1656 
      raise x
1657 
    result = getComingSoonCount_result()
1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
1660 
    if result.success is not None:
1661 
      return result.success
1662 
    if result.cex is not None:
1663 
      raise result.cex
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1665 
 
1666 
  def getLatestArrivals(self, ):
1667 
    """
1668 
    Returns a list of items sorted in the descending order by start date.
1669 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1670 
    """
1671 
    self.send_getLatestArrivals()
1672 
    return self.recv_getLatestArrivals()
1673 
 
1674 
  def send_getLatestArrivals(self, ):
1675 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1676 
    args = getLatestArrivals_args()
1677 
    args.write(self._oprot)
1678 
    self._oprot.writeMessageEnd()
1679 
    self._oprot.trans.flush()
1680 
 
1681 
  def recv_getLatestArrivals(self, ):
1682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1683 
    if mtype == TMessageType.EXCEPTION:
1684 
      x = TApplicationException()
1685 
      x.read(self._iprot)
1686 
      self._iprot.readMessageEnd()
1687 
      raise x
1688 
    result = getLatestArrivals_result()
1689 
    result.read(self._iprot)
1690 
    self._iprot.readMessageEnd()
1691 
    if result.success is not None:
1692 
      return result.success
1693 
    if result.isex is not None:
1694 
      raise result.isex
1695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1696 
 
1697 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1698 
    """
1699 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1700 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1701 
 
1702 
    Parameters:
1703 
     - beginIndex
1704 
     - totalItems
1705 
     - brand
1706 
     - categories
1707 
    """
1708 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1709 
    return self.recv_getLatestArrivalsCatalogIds()
1710 
 
1711 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1712 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1713 
    args = getLatestArrivalsCatalogIds_args()
1714 
    args.beginIndex = beginIndex
1715 
    args.totalItems = totalItems
1716 
    args.brand = brand
1717 
    args.categories = categories
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getLatestArrivalsCatalogIds(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getLatestArrivalsCatalogIds_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
1732 
    if result.success is not None:
1733 
      return result.success
1734 
    if result.cex is not None:
1735 
      raise result.cex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1737 
 
1738 
  def getLatestArrivalsCount(self, ):
1739 
    """
1740 
    Get the total number of latest arrivals we are willing to show.
1741 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1742 
    """
1743 
    self.send_getLatestArrivalsCount()
1744 
    return self.recv_getLatestArrivalsCount()
1745 
 
1746 
  def send_getLatestArrivalsCount(self, ):
1747 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1748 
    args = getLatestArrivalsCount_args()
1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getLatestArrivalsCount(self, ):
1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
1760 
    result = getLatestArrivalsCount_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
1763 
    if result.success is not None:
1764 
      return result.success
1765 
    if result.cex is not None:
1766 
      raise result.cex
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1768 
 
1769 
  def generateNewEntityID(self, ):
1770 
    self.send_generateNewEntityID()
1771 
    return self.recv_generateNewEntityID()
1772 
 
1773 
  def send_generateNewEntityID(self, ):
1774 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1775 
    args = generateNewEntityID_args()
1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
1780 
  def recv_generateNewEntityID(self, ):
1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
1787 
    result = generateNewEntityID_result()
1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
1790 
    if result.success is not None:
1791 
      return result.success
1792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1793 
 
1794 
  def addCategory(self, category):
1795 
    """
1796 
    All category related functions
1797 
 
1798 
    Parameters:
1799 
     - category
1800 
    """
1801 
    self.send_addCategory(category)
1802 
    return self.recv_addCategory()
1803 
 
1804 
  def send_addCategory(self, category):
1805 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1806 
    args = addCategory_args()
1807 
    args.category = category
1808 
    args.write(self._oprot)
1809 
    self._oprot.writeMessageEnd()
1810 
    self._oprot.trans.flush()
1811 
 
1812 
  def recv_addCategory(self, ):
1813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1814 
    if mtype == TMessageType.EXCEPTION:
1815 
      x = TApplicationException()
1816 
      x.read(self._iprot)
1817 
      self._iprot.readMessageEnd()
1818 
      raise x
1819 
    result = addCategory_result()
1820 
    result.read(self._iprot)
1821 
    self._iprot.readMessageEnd()
1822 
    if result.success is not None:
1823 
      return result.success
1824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1825 
 
1826 
  def getCategory(self, id):
1827 
    """
1828 
    Parameters:
1829 
     - id
1830 
    """
1831 
    self.send_getCategory(id)
1832 
    return self.recv_getCategory()
1833 
 
1834 
  def send_getCategory(self, id):
1835 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1836 
    args = getCategory_args()
1837 
    args.id = id
1838 
    args.write(self._oprot)
1839 
    self._oprot.writeMessageEnd()
1840 
    self._oprot.trans.flush()
1841 
 
1842 
  def recv_getCategory(self, ):
1843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1844 
    if mtype == TMessageType.EXCEPTION:
1845 
      x = TApplicationException()
1846 
      x.read(self._iprot)
1847 
      self._iprot.readMessageEnd()
1848 
      raise x
1849 
    result = getCategory_result()
1850 
    result.read(self._iprot)
1851 
    self._iprot.readMessageEnd()
1852 
    if result.success is not None:
1853 
      return result.success
1854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1855 
 
1856 
  def getAllCategories(self, ):
1857 
    self.send_getAllCategories()
1858 
    return self.recv_getAllCategories()
1859 
 
1860 
  def send_getAllCategories(self, ):
1861 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1862 
    args = getAllCategories_args()
1863 
    args.write(self._oprot)
1864 
    self._oprot.writeMessageEnd()
1865 
    self._oprot.trans.flush()
1866 
 
1867 
  def recv_getAllCategories(self, ):
1868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1869 
    if mtype == TMessageType.EXCEPTION:
1870 
      x = TApplicationException()
1871 
      x.read(self._iprot)
1872 
      self._iprot.readMessageEnd()
1873 
      raise x
1874 
    result = getAllCategories_result()
1875 
    result.read(self._iprot)
1876 
    self._iprot.readMessageEnd()
1877 
    if result.success is not None:
1878 
      return result.success
1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1880 
 
1881 
  def getAllSimilarItems(self, itemId):
1882 
    """
1883 
    Returns the list of similar items.
1884 
 
1885 
    Parameters:
1886 
     - itemId
1887 
    """
1888 
    self.send_getAllSimilarItems(itemId)
1889 
    return self.recv_getAllSimilarItems()
1890 
 
1891 
  def send_getAllSimilarItems(self, itemId):
1892 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1893 
    args = getAllSimilarItems_args()
1894 
    args.itemId = itemId
1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
1899 
  def recv_getAllSimilarItems(self, ):
1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
1906 
    result = getAllSimilarItems_result()
1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
1909 
    if result.success is not None:
1910 
      return result.success
1911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1912 
 
1913 
  def addSimilarItem(self, itemId, catalogItemId):
1914 
    """
1915 
    Adds similar item.
1916 
 
1917 
    Parameters:
1918 
     - itemId
1919 
     - catalogItemId
1920 
    """
1921 
    self.send_addSimilarItem(itemId, catalogItemId)
1922 
    return self.recv_addSimilarItem()
1923 
 
1924 
  def send_addSimilarItem(self, itemId, catalogItemId):
1925 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1926 
    args = addSimilarItem_args()
1927 
    args.itemId = itemId
1928 
    args.catalogItemId = catalogItemId
1929 
    args.write(self._oprot)
1930 
    self._oprot.writeMessageEnd()
1931 
    self._oprot.trans.flush()
1932 
 
1933 
  def recv_addSimilarItem(self, ):
1934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1935 
    if mtype == TMessageType.EXCEPTION:
1936 
      x = TApplicationException()
1937 
      x.read(self._iprot)
1938 
      self._iprot.readMessageEnd()
1939 
      raise x
1940 
    result = addSimilarItem_result()
1941 
    result.read(self._iprot)
1942 
    self._iprot.readMessageEnd()
1943 
    if result.success is not None:
1944 
      return result.success
1945 
    if result.cex is not None:
1946 
      raise result.cex
1947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1948 
 
6512 kshitij.so 1949 
  def addTag(self, displayName, itemId):
1950 
    """
1951 
    Tag Related
1952 
 
1953 
    Parameters:
1954 
     - displayName
1955 
     - itemId
1956 
    """
1957 
    self.send_addTag(displayName, itemId)
1958 
    return self.recv_addTag()
1959 
 
1960 
  def send_addTag(self, displayName, itemId):
1961 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1962 
    args = addTag_args()
1963 
    args.displayName = displayName
1964 
    args.itemId = itemId
1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
1969 
  def recv_addTag(self, ):
1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
1976 
    result = addTag_result()
1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
1979 
    if result.success is not None:
1980 
      return result.success
1981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1982 
 
1983 
  def deleteEntityTag(self, displayName, itemId):
1984 
    """
1985 
    Parameters:
1986 
     - displayName
1987 
     - itemId
1988 
    """
1989 
    self.send_deleteEntityTag(displayName, itemId)
1990 
    return self.recv_deleteEntityTag()
1991 
 
1992 
  def send_deleteEntityTag(self, displayName, itemId):
1993 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1994 
    args = deleteEntityTag_args()
1995 
    args.displayName = displayName
1996 
    args.itemId = itemId
1997 
    args.write(self._oprot)
1998 
    self._oprot.writeMessageEnd()
1999 
    self._oprot.trans.flush()
2000 
 
2001 
  def recv_deleteEntityTag(self, ):
2002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2003 
    if mtype == TMessageType.EXCEPTION:
2004 
      x = TApplicationException()
2005 
      x.read(self._iprot)
2006 
      self._iprot.readMessageEnd()
2007 
      raise x
2008 
    result = deleteEntityTag_result()
2009 
    result.read(self._iprot)
2010 
    self._iprot.readMessageEnd()
2011 
    if result.success is not None:
2012 
      return result.success
2013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2014 
 
2015 
  def deleteTag(self, displayName):
2016 
    """
2017 
    Parameters:
2018 
     - displayName
2019 
    """
2020 
    self.send_deleteTag(displayName)
2021 
    return self.recv_deleteTag()
2022 
 
2023 
  def send_deleteTag(self, displayName):
2024 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2025 
    args = deleteTag_args()
2026 
    args.displayName = displayName
2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
2031 
  def recv_deleteTag(self, ):
2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
2038 
    result = deleteTag_result()
2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
2041 
    if result.success is not None:
2042 
      return result.success
2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2044 
 
2045 
  def getAllTags(self, ):
2046 
    self.send_getAllTags()
2047 
    return self.recv_getAllTags()
2048 
 
2049 
  def send_getAllTags(self, ):
2050 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2051 
    args = getAllTags_args()
2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
2056 
  def recv_getAllTags(self, ):
2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
2063 
    result = getAllTags_result()
2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
2066 
    if result.success is not None:
2067 
      return result.success
2068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2069 
 
2070 
  def getAllEntitiesByTagName(self, displayName):
2071 
    """
2072 
    Parameters:
2073 
     - displayName
2074 
    """
2075 
    self.send_getAllEntitiesByTagName(displayName)
2076 
    return self.recv_getAllEntitiesByTagName()
2077 
 
2078 
  def send_getAllEntitiesByTagName(self, displayName):
2079 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2080 
    args = getAllEntitiesByTagName_args()
2081 
    args.displayName = displayName
2082 
    args.write(self._oprot)
2083 
    self._oprot.writeMessageEnd()
2084 
    self._oprot.trans.flush()
2085 
 
2086 
  def recv_getAllEntitiesByTagName(self, ):
2087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2088 
    if mtype == TMessageType.EXCEPTION:
2089 
      x = TApplicationException()
2090 
      x.read(self._iprot)
2091 
      self._iprot.readMessageEnd()
2092 
      raise x
2093 
    result = getAllEntitiesByTagName_result()
2094 
    result.read(self._iprot)
2095 
    self._iprot.readMessageEnd()
2096 
    if result.success is not None:
2097 
      return result.success
2098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2099 
 
6845 amit.gupta 2100 
  def getAllEntityTags(self, ):
2101 
    self.send_getAllEntityTags()
2102 
    return self.recv_getAllEntityTags()
2103 
 
2104 
  def send_getAllEntityTags(self, ):
2105 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2106 
    args = getAllEntityTags_args()
2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getAllEntityTags(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getAllEntityTags_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
2121 
    if result.success is not None:
2122 
      return result.success
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2124 
 
6850 kshitij.so 2125 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2126 
    """
2127 
    Parameters:
2128 
     - bannerName
2129 
     - imageName
2130 
     - link
2131 
     - priority
2132 
     - isActive
2133 
     - hasMap
2134 
    """
2135 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2136 
    return self.recv_addBanner()
2137 
 
2138 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2139 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2140 
    args = addBanner_args()
2141 
    args.bannerName = bannerName
2142 
    args.imageName = imageName
2143 
    args.link = link
2144 
    args.priority = priority
2145 
    args.isActive = isActive
2146 
    args.hasMap = hasMap
2147 
    args.write(self._oprot)
2148 
    self._oprot.writeMessageEnd()
2149 
    self._oprot.trans.flush()
2150 
 
2151 
  def recv_addBanner(self, ):
2152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2153 
    if mtype == TMessageType.EXCEPTION:
2154 
      x = TApplicationException()
2155 
      x.read(self._iprot)
2156 
      self._iprot.readMessageEnd()
2157 
      raise x
2158 
    result = addBanner_result()
2159 
    result.read(self._iprot)
2160 
    self._iprot.readMessageEnd()
2161 
    if result.success is not None:
2162 
      return result.success
2163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2164 
 
2165 
  def getAllBanners(self, ):
2166 
    self.send_getAllBanners()
2167 
    return self.recv_getAllBanners()
2168 
 
2169 
  def send_getAllBanners(self, ):
2170 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2171 
    args = getAllBanners_args()
2172 
    args.write(self._oprot)
2173 
    self._oprot.writeMessageEnd()
2174 
    self._oprot.trans.flush()
2175 
 
2176 
  def recv_getAllBanners(self, ):
2177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2178 
    if mtype == TMessageType.EXCEPTION:
2179 
      x = TApplicationException()
2180 
      x.read(self._iprot)
2181 
      self._iprot.readMessageEnd()
2182 
      raise x
2183 
    result = getAllBanners_result()
2184 
    result.read(self._iprot)
2185 
    self._iprot.readMessageEnd()
2186 
    if result.success is not None:
2187 
      return result.success
2188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2189 
 
2190 
  def deleteBanner(self, bannerName):
2191 
    """
2192 
    Parameters:
2193 
     - bannerName
2194 
    """
2195 
    self.send_deleteBanner(bannerName)
2196 
    return self.recv_deleteBanner()
2197 
 
2198 
  def send_deleteBanner(self, bannerName):
2199 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2200 
    args = deleteBanner_args()
2201 
    args.bannerName = bannerName
2202 
    args.write(self._oprot)
2203 
    self._oprot.writeMessageEnd()
2204 
    self._oprot.trans.flush()
2205 
 
2206 
  def recv_deleteBanner(self, ):
2207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2208 
    if mtype == TMessageType.EXCEPTION:
2209 
      x = TApplicationException()
2210 
      x.read(self._iprot)
2211 
      self._iprot.readMessageEnd()
2212 
      raise x
2213 
    result = deleteBanner_result()
2214 
    result.read(self._iprot)
2215 
    self._iprot.readMessageEnd()
2216 
    if result.success is not None:
2217 
      return result.success
2218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2219 
 
2220 
  def getBannerDetails(self, bannerName):
2221 
    """
2222 
    Parameters:
2223 
     - bannerName
2224 
    """
2225 
    self.send_getBannerDetails(bannerName)
2226 
    return self.recv_getBannerDetails()
2227 
 
2228 
  def send_getBannerDetails(self, bannerName):
2229 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2230 
    args = getBannerDetails_args()
2231 
    args.bannerName = bannerName
2232 
    args.write(self._oprot)
2233 
    self._oprot.writeMessageEnd()
2234 
    self._oprot.trans.flush()
2235 
 
2236 
  def recv_getBannerDetails(self, ):
2237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2238 
    if mtype == TMessageType.EXCEPTION:
2239 
      x = TApplicationException()
2240 
      x.read(self._iprot)
2241 
      self._iprot.readMessageEnd()
2242 
      raise x
2243 
    result = getBannerDetails_result()
2244 
    result.read(self._iprot)
2245 
    self._iprot.readMessageEnd()
2246 
    if result.success is not None:
2247 
      return result.success
2248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2249 
 
2250 
  def getActiveBanners(self, ):
2251 
    self.send_getActiveBanners()
2252 
    return self.recv_getActiveBanners()
2253 
 
2254 
  def send_getActiveBanners(self, ):
2255 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2256 
    args = getActiveBanners_args()
2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
2261 
  def recv_getActiveBanners(self, ):
2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
2268 
    result = getActiveBanners_result()
2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
2271 
    if result.success is not None:
2272 
      return result.success
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2274 
 
6849 kshitij.so 2275 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2276 
    """
2277 
    Parameters:
2278 
     - bannerName
2279 
     - mapLink
2280 
     - coordinates
2281 
    """
2282 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2283 
    return self.recv_addBannerMap()
2284 
 
2285 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2286 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2287 
    args = addBannerMap_args()
2288 
    args.bannerName = bannerName
2289 
    args.mapLink = mapLink
2290 
    args.coordinates = coordinates
2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
2295 
  def recv_addBannerMap(self, ):
2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
2302 
    result = addBannerMap_result()
2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
2305 
    if result.success is not None:
2306 
      return result.success
2307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2308 
 
2309 
  def deleteBannerMap(self, bannerName):
2310 
    """
2311 
    Parameters:
2312 
     - bannerName
2313 
    """
2314 
    self.send_deleteBannerMap(bannerName)
2315 
    return self.recv_deleteBannerMap()
2316 
 
2317 
  def send_deleteBannerMap(self, bannerName):
2318 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2319 
    args = deleteBannerMap_args()
2320 
    args.bannerName = bannerName
2321 
    args.write(self._oprot)
2322 
    self._oprot.writeMessageEnd()
2323 
    self._oprot.trans.flush()
2324 
 
2325 
  def recv_deleteBannerMap(self, ):
2326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2327 
    if mtype == TMessageType.EXCEPTION:
2328 
      x = TApplicationException()
2329 
      x.read(self._iprot)
2330 
      self._iprot.readMessageEnd()
2331 
      raise x
2332 
    result = deleteBannerMap_result()
2333 
    result.read(self._iprot)
2334 
    self._iprot.readMessageEnd()
2335 
    if result.success is not None:
2336 
      return result.success
2337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2338 
 
2339 
  def getBannerMapDetails(self, bannerName):
2340 
    """
2341 
    Parameters:
2342 
     - bannerName
2343 
    """
2344 
    self.send_getBannerMapDetails(bannerName)
2345 
    return self.recv_getBannerMapDetails()
2346 
 
2347 
  def send_getBannerMapDetails(self, bannerName):
2348 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2349 
    args = getBannerMapDetails_args()
2350 
    args.bannerName = bannerName
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_getBannerMapDetails(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = getBannerMapDetails_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    if result.success is not None:
2366 
      return result.success
2367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2368 
 
5944 mandeep.dh 2369 
  def deleteSimilarItem(self, itemId, catalogItemId):
2370 
    """
2371 
    Delete similar item.
2372 
 
2373 
    Parameters:
2374 
     - itemId
2375 
     - catalogItemId
2376 
    """
2377 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2378 
    return self.recv_deleteSimilarItem()
2379 
 
2380 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2381 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2382 
    args = deleteSimilarItem_args()
2383 
    args.itemId = itemId
2384 
    args.catalogItemId = catalogItemId
2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
2389 
  def recv_deleteSimilarItem(self, ):
2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
2396 
    result = deleteSimilarItem_result()
2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
2399 
    if result.success is not None:
2400 
      return result.success
2401 
    if result.cex is not None:
2402 
      raise result.cex
2403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2404 
 
2405 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2406 
    """
2407 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2408 
    If yes, returns the itemId else returns 0
2409 
 
2410 
    Parameters:
2411 
     - brand
2412 
     - modelNumber
2413 
     - modelName
2414 
     - color
2415 
    """
2416 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2417 
    return self.recv_checkSimilarItem()
2418 
 
2419 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2420 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2421 
    args = checkSimilarItem_args()
2422 
    args.brand = brand
2423 
    args.modelNumber = modelNumber
2424 
    args.modelName = modelName
2425 
    args.color = color
2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
2430 
  def recv_checkSimilarItem(self, ):
2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
2437 
    result = checkSimilarItem_result()
2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
2440 
    if result.success is not None:
2441 
      return result.success
2442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2443 
 
2444 
  def validateRiskyStatus(self, itemId):
2445 
    """
2446 
    Check wether item is risky and change status if inventory is not available for risky items
2447 
 
2448 
    Parameters:
2449 
     - itemId
2450 
    """
2451 
    self.send_validateRiskyStatus(itemId)
2452 
    self.recv_validateRiskyStatus()
2453 
 
2454 
  def send_validateRiskyStatus(self, itemId):
2455 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2456 
    args = validateRiskyStatus_args()
2457 
    args.itemId = itemId
2458 
    args.write(self._oprot)
2459 
    self._oprot.writeMessageEnd()
2460 
    self._oprot.trans.flush()
2461 
 
2462 
  def recv_validateRiskyStatus(self, ):
2463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2464 
    if mtype == TMessageType.EXCEPTION:
2465 
      x = TApplicationException()
2466 
      x.read(self._iprot)
2467 
      self._iprot.readMessageEnd()
2468 
      raise x
2469 
    result = validateRiskyStatus_result()
2470 
    result.read(self._iprot)
2471 
    self._iprot.readMessageEnd()
2472 
    return
2473 
 
2474 
  def changeItemRiskyFlag(self, itemId, risky):
2475 
    """
2476 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2477 
 
2478 
    Parameters:
2479 
     - itemId
2480 
     - risky
2481 
    """
2482 
    self.send_changeItemRiskyFlag(itemId, risky)
2483 
    self.recv_changeItemRiskyFlag()
2484 
 
2485 
  def send_changeItemRiskyFlag(self, itemId, risky):
2486 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2487 
    args = changeItemRiskyFlag_args()
2488 
    args.itemId = itemId
2489 
    args.risky = risky
2490 
    args.write(self._oprot)
2491 
    self._oprot.writeMessageEnd()
2492 
    self._oprot.trans.flush()
2493 
 
2494 
  def recv_changeItemRiskyFlag(self, ):
2495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2496 
    if mtype == TMessageType.EXCEPTION:
2497 
      x = TApplicationException()
2498 
      x.read(self._iprot)
2499 
      self._iprot.readMessageEnd()
2500 
      raise x
2501 
    result = changeItemRiskyFlag_result()
2502 
    result.read(self._iprot)
2503 
    self._iprot.readMessageEnd()
2504 
    return
2505 
 
2506 
  def getItemsByRiskyFlag(self, ):
2507 
    """
2508 
    Returns list of items marked as risky.
2509 
    """
2510 
    self.send_getItemsByRiskyFlag()
2511 
    return self.recv_getItemsByRiskyFlag()
2512 
 
2513 
  def send_getItemsByRiskyFlag(self, ):
2514 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2515 
    args = getItemsByRiskyFlag_args()
2516 
    args.write(self._oprot)
2517 
    self._oprot.writeMessageEnd()
2518 
    self._oprot.trans.flush()
2519 
 
2520 
  def recv_getItemsByRiskyFlag(self, ):
2521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2522 
    if mtype == TMessageType.EXCEPTION:
2523 
      x = TApplicationException()
2524 
      x.read(self._iprot)
2525 
      self._iprot.readMessageEnd()
2526 
      raise x
2527 
    result = getItemsByRiskyFlag_result()
2528 
    result.read(self._iprot)
2529 
    self._iprot.readMessageEnd()
2530 
    if result.success is not None:
2531 
      return result.success
2532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2533 
 
2534 
  def getItemsForMasterSheet(self, category, brand):
2535 
    """
2536 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2537 
 
2538 
    Parameters:
2539 
     - category
2540 
     - brand
2541 
    """
2542 
    self.send_getItemsForMasterSheet(category, brand)
2543 
    return self.recv_getItemsForMasterSheet()
2544 
 
2545 
  def send_getItemsForMasterSheet(self, category, brand):
2546 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2547 
    args = getItemsForMasterSheet_args()
2548 
    args.category = category
2549 
    args.brand = brand
2550 
    args.write(self._oprot)
2551 
    self._oprot.writeMessageEnd()
2552 
    self._oprot.trans.flush()
2553 
 
2554 
  def recv_getItemsForMasterSheet(self, ):
2555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2556 
    if mtype == TMessageType.EXCEPTION:
2557 
      x = TApplicationException()
2558 
      x.read(self._iprot)
2559 
      self._iprot.readMessageEnd()
2560 
      raise x
2561 
    result = getItemsForMasterSheet_result()
2562 
    result.read(self._iprot)
2563 
    self._iprot.readMessageEnd()
2564 
    if result.success is not None:
2565 
      return result.success
2566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2567 
 
2568 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2569 
    """
2570 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2571 
 
2572 
    Parameters:
2573 
     - beginIndex
2574 
     - totalItems
2575 
     - itemId
2576 
    """
2577 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2578 
    return self.recv_getSimilarItemsCatalogIds()
2579 
 
2580 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2581 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2582 
    args = getSimilarItemsCatalogIds_args()
2583 
    args.beginIndex = beginIndex
2584 
    args.totalItems = totalItems
2585 
    args.itemId = itemId
2586 
    args.write(self._oprot)
2587 
    self._oprot.writeMessageEnd()
2588 
    self._oprot.trans.flush()
2589 
 
2590 
  def recv_getSimilarItemsCatalogIds(self, ):
2591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2592 
    if mtype == TMessageType.EXCEPTION:
2593 
      x = TApplicationException()
2594 
      x.read(self._iprot)
2595 
      self._iprot.readMessageEnd()
2596 
      raise x
2597 
    result = getSimilarItemsCatalogIds_result()
2598 
    result.read(self._iprot)
2599 
    self._iprot.readMessageEnd()
2600 
    if result.success is not None:
2601 
      return result.success
2602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2603 
 
2604 
  def addProductNotification(self, itemId, email):
2605 
    """
2606 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2607 
 
2608 
    Parameters:
2609 
     - itemId
2610 
     - email
2611 
    """
2612 
    self.send_addProductNotification(itemId, email)
2613 
    return self.recv_addProductNotification()
2614 
 
2615 
  def send_addProductNotification(self, itemId, email):
2616 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2617 
    args = addProductNotification_args()
2618 
    args.itemId = itemId
2619 
    args.email = email
2620 
    args.write(self._oprot)
2621 
    self._oprot.writeMessageEnd()
2622 
    self._oprot.trans.flush()
2623 
 
2624 
  def recv_addProductNotification(self, ):
2625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2626 
    if mtype == TMessageType.EXCEPTION:
2627 
      x = TApplicationException()
2628 
      x.read(self._iprot)
2629 
      self._iprot.readMessageEnd()
2630 
      raise x
2631 
    result = addProductNotification_result()
2632 
    result.read(self._iprot)
2633 
    self._iprot.readMessageEnd()
2634 
    if result.success is not None:
2635 
      return result.success
2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2637 
 
2638 
  def sendProductNotifications(self, ):
2639 
    """
2640 
    Send the product notifications to the users for items which has stock.
2641 
    """
2642 
    self.send_sendProductNotifications()
2643 
    return self.recv_sendProductNotifications()
2644 
 
2645 
  def send_sendProductNotifications(self, ):
2646 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2647 
    args = sendProductNotifications_args()
2648 
    args.write(self._oprot)
2649 
    self._oprot.writeMessageEnd()
2650 
    self._oprot.trans.flush()
2651 
 
2652 
  def recv_sendProductNotifications(self, ):
2653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2654 
    if mtype == TMessageType.EXCEPTION:
2655 
      x = TApplicationException()
2656 
      x.read(self._iprot)
2657 
      self._iprot.readMessageEnd()
2658 
      raise x
2659 
    result = sendProductNotifications_result()
2660 
    result.read(self._iprot)
2661 
    self._iprot.readMessageEnd()
2662 
    if result.success is not None:
2663 
      return result.success
2664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2665 
 
2666 
  def getAllBrandsByCategory(self, categoryId):
2667 
    """
2668 
    Returns list of brand names for a given category Id
2669 
 
2670 
    Parameters:
2671 
     - categoryId
2672 
    """
2673 
    self.send_getAllBrandsByCategory(categoryId)
2674 
    return self.recv_getAllBrandsByCategory()
2675 
 
2676 
  def send_getAllBrandsByCategory(self, categoryId):
2677 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2678 
    args = getAllBrandsByCategory_args()
2679 
    args.categoryId = categoryId
2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
2684 
  def recv_getAllBrandsByCategory(self, ):
2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
2691 
    result = getAllBrandsByCategory_result()
2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.success is not None:
2695 
      return result.success
2696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2697 
 
2698 
  def getAllBrands(self, ):
2699 
    """
2700 
    Returns list of brand names
2701 
    """
2702 
    self.send_getAllBrands()
2703 
    return self.recv_getAllBrands()
2704 
 
2705 
  def send_getAllBrands(self, ):
2706 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2707 
    args = getAllBrands_args()
2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2712 
  def recv_getAllBrands(self, ):
2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2719 
    result = getAllBrands_result()
2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
2722 
    if result.success is not None:
2723 
      return result.success
2724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2725 
 
2726 
  def getAllSources(self, ):
2727 
    """
2728 
    Return list of all sources
2729 
    """
2730 
    self.send_getAllSources()
2731 
    return self.recv_getAllSources()
2732 
 
2733 
  def send_getAllSources(self, ):
2734 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2735 
    args = getAllSources_args()
2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
2740 
  def recv_getAllSources(self, ):
2741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2742 
    if mtype == TMessageType.EXCEPTION:
2743 
      x = TApplicationException()
2744 
      x.read(self._iprot)
2745 
      self._iprot.readMessageEnd()
2746 
      raise x
2747 
    result = getAllSources_result()
2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
2750 
    if result.success is not None:
2751 
      return result.success
2752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2753 
 
2754 
  def getItemPricingBySource(self, itemId, sourceId):
2755 
    """
2756 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2757 
 
2758 
    Parameters:
2759 
     - itemId
2760 
     - sourceId
2761 
    """
2762 
    self.send_getItemPricingBySource(itemId, sourceId)
2763 
    return self.recv_getItemPricingBySource()
2764 
 
2765 
  def send_getItemPricingBySource(self, itemId, sourceId):
2766 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2767 
    args = getItemPricingBySource_args()
2768 
    args.itemId = itemId
2769 
    args.sourceId = sourceId
2770 
    args.write(self._oprot)
2771 
    self._oprot.writeMessageEnd()
2772 
    self._oprot.trans.flush()
2773 
 
2774 
  def recv_getItemPricingBySource(self, ):
2775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2776 
    if mtype == TMessageType.EXCEPTION:
2777 
      x = TApplicationException()
2778 
      x.read(self._iprot)
2779 
      self._iprot.readMessageEnd()
2780 
      raise x
2781 
    result = getItemPricingBySource_result()
2782 
    result.read(self._iprot)
2783 
    self._iprot.readMessageEnd()
2784 
    if result.success is not None:
2785 
      return result.success
2786 
    if result.cex is not None:
2787 
      raise result.cex
2788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2789 
 
2790 
  def addSourceItemPricing(self, sourceItemPricing):
2791 
    """
2792 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2793 
    If item is not found or source is not found, it will throw exception.
2794 
 
2795 
    Parameters:
2796 
     - sourceItemPricing
2797 
    """
2798 
    self.send_addSourceItemPricing(sourceItemPricing)
2799 
    self.recv_addSourceItemPricing()
2800 
 
2801 
  def send_addSourceItemPricing(self, sourceItemPricing):
2802 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2803 
    args = addSourceItemPricing_args()
2804 
    args.sourceItemPricing = sourceItemPricing
2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
2809 
  def recv_addSourceItemPricing(self, ):
2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
2816 
    result = addSourceItemPricing_result()
2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
2819 
    if result.cex is not None:
2820 
      raise result.cex
2821 
    return
2822 
 
2823 
  def getAllSourcePricing(self, itemId):
2824 
    """
2825 
    Returns the list of source pricing information of an item.
2826 
    Raises an exception if item not found corresponding to itemId
2827 
 
2828 
    Parameters:
2829 
     - itemId
2830 
    """
2831 
    self.send_getAllSourcePricing(itemId)
2832 
    return self.recv_getAllSourcePricing()
2833 
 
2834 
  def send_getAllSourcePricing(self, itemId):
2835 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2836 
    args = getAllSourcePricing_args()
2837 
    args.itemId = itemId
2838 
    args.write(self._oprot)
2839 
    self._oprot.writeMessageEnd()
2840 
    self._oprot.trans.flush()
2841 
 
2842 
  def recv_getAllSourcePricing(self, ):
2843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2844 
    if mtype == TMessageType.EXCEPTION:
2845 
      x = TApplicationException()
2846 
      x.read(self._iprot)
2847 
      self._iprot.readMessageEnd()
2848 
      raise x
2849 
    result = getAllSourcePricing_result()
2850 
    result.read(self._iprot)
2851 
    self._iprot.readMessageEnd()
2852 
    if result.success is not None:
2853 
      return result.success
2854 
    if result.cex is not None:
2855 
      raise result.cex
2856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2857 
 
2858 
  def getItemForSource(self, item_id, sourceId):
2859 
    """
2860 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2861 
 
2862 
    Parameters:
2863 
     - item_id
2864 
     - sourceId
2865 
    """
2866 
    self.send_getItemForSource(item_id, sourceId)
2867 
    return self.recv_getItemForSource()
2868 
 
2869 
  def send_getItemForSource(self, item_id, sourceId):
2870 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2871 
    args = getItemForSource_args()
2872 
    args.item_id = item_id
2873 
    args.sourceId = sourceId
2874 
    args.write(self._oprot)
2875 
    self._oprot.writeMessageEnd()
2876 
    self._oprot.trans.flush()
2877 
 
2878 
  def recv_getItemForSource(self, ):
2879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2880 
    if mtype == TMessageType.EXCEPTION:
2881 
      x = TApplicationException()
2882 
      x.read(self._iprot)
2883 
      self._iprot.readMessageEnd()
2884 
      raise x
2885 
    result = getItemForSource_result()
2886 
    result.read(self._iprot)
2887 
    self._iprot.readMessageEnd()
2888 
    if result.success is not None:
2889 
      return result.success
2890 
    if result.cex is not None:
2891 
      raise result.cex
2892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2893 
 
2894 
  def searchItemsInRange(self, searchTerms, offset, limit):
2895 
    """
2896 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2897 
 
2898 
    Parameters:
2899 
     - searchTerms
2900 
     - offset
2901 
     - limit
2902 
    """
2903 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2904 
    return self.recv_searchItemsInRange()
2905 
 
2906 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2907 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2908 
    args = searchItemsInRange_args()
2909 
    args.searchTerms = searchTerms
2910 
    args.offset = offset
2911 
    args.limit = limit
2912 
    args.write(self._oprot)
2913 
    self._oprot.writeMessageEnd()
2914 
    self._oprot.trans.flush()
2915 
 
2916 
  def recv_searchItemsInRange(self, ):
2917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2918 
    if mtype == TMessageType.EXCEPTION:
2919 
      x = TApplicationException()
2920 
      x.read(self._iprot)
2921 
      self._iprot.readMessageEnd()
2922 
      raise x
2923 
    result = searchItemsInRange_result()
2924 
    result.read(self._iprot)
2925 
    self._iprot.readMessageEnd()
2926 
    if result.success is not None:
2927 
      return result.success
2928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2929 
 
2930 
  def getSearchResultCount(self, searchTerms):
2931 
    """
2932 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2933 
 
2934 
    Parameters:
2935 
     - searchTerms
2936 
    """
2937 
    self.send_getSearchResultCount(searchTerms)
2938 
    return self.recv_getSearchResultCount()
2939 
 
2940 
  def send_getSearchResultCount(self, searchTerms):
2941 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2942 
    args = getSearchResultCount_args()
2943 
    args.searchTerms = searchTerms
2944 
    args.write(self._oprot)
2945 
    self._oprot.writeMessageEnd()
2946 
    self._oprot.trans.flush()
2947 
 
2948 
  def recv_getSearchResultCount(self, ):
2949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2950 
    if mtype == TMessageType.EXCEPTION:
2951 
      x = TApplicationException()
2952 
      x.read(self._iprot)
2953 
      self._iprot.readMessageEnd()
2954 
      raise x
2955 
    result = getSearchResultCount_result()
2956 
    result.read(self._iprot)
2957 
    self._iprot.readMessageEnd()
2958 
    if result.success is not None:
2959 
      return result.success
2960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2961 
 
2962 
  def getProductNotifications(self, startDateTime):
2963 
    """
2964 
    Returns a list of product notifications added after a supplied datetime
2965 
 
2966 
    Parameters:
2967 
     - startDateTime
2968 
    """
2969 
    self.send_getProductNotifications(startDateTime)
2970 
    return self.recv_getProductNotifications()
2971 
 
2972 
  def send_getProductNotifications(self, startDateTime):
2973 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2974 
    args = getProductNotifications_args()
2975 
    args.startDateTime = startDateTime
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_getProductNotifications(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = getProductNotifications_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
2990 
    if result.success is not None:
2991 
      return result.success
2992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2993 
 
7897 amar.kumar 2994 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2995 
    """
2996 
    Returns a list of count of requests for product notification against each item
2997 
 
2998 
    Parameters:
2999 
     - startDateTime
7897 amar.kumar 3000 
     - categoryId
5944 mandeep.dh 3001 
    """
7897 amar.kumar 3002 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3003 
    return self.recv_getProductNotificationRequestCount()
3004 
 
7897 amar.kumar 3005 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3006 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3007 
    args = getProductNotificationRequestCount_args()
3008 
    args.startDateTime = startDateTime
7897 amar.kumar 3009 
    args.categoryId = categoryId
5944 mandeep.dh 3010 
    args.write(self._oprot)
3011 
    self._oprot.writeMessageEnd()
3012 
    self._oprot.trans.flush()
3013 
 
3014 
  def recv_getProductNotificationRequestCount(self, ):
3015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3016 
    if mtype == TMessageType.EXCEPTION:
3017 
      x = TApplicationException()
3018 
      x.read(self._iprot)
3019 
      self._iprot.readMessageEnd()
3020 
      raise x
3021 
    result = getProductNotificationRequestCount_result()
3022 
    result.read(self._iprot)
3023 
    self._iprot.readMessageEnd()
3024 
    if result.success is not None:
3025 
      return result.success
3026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3027 
 
3028 
  def addAuthorizationLog(self, itemId, username, reason):
3029 
    """
3030 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3031 
 
3032 
    Parameters:
3033 
     - itemId
3034 
     - username
3035 
     - reason
3036 
    """
3037 
    self.send_addAuthorizationLog(itemId, username, reason)
3038 
    return self.recv_addAuthorizationLog()
3039 
 
3040 
  def send_addAuthorizationLog(self, itemId, username, reason):
3041 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3042 
    args = addAuthorizationLog_args()
3043 
    args.itemId = itemId
3044 
    args.username = username
3045 
    args.reason = reason
3046 
    args.write(self._oprot)
3047 
    self._oprot.writeMessageEnd()
3048 
    self._oprot.trans.flush()
3049 
 
3050 
  def recv_addAuthorizationLog(self, ):
3051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3052 
    if mtype == TMessageType.EXCEPTION:
3053 
      x = TApplicationException()
3054 
      x.read(self._iprot)
3055 
      self._iprot.readMessageEnd()
3056 
      raise x
3057 
    result = addAuthorizationLog_result()
3058 
    result.read(self._iprot)
3059 
    self._iprot.readMessageEnd()
3060 
    if result.success is not None:
3061 
      return result.success
3062 
    if result.cex is not None:
3063 
      raise result.cex
3064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3065 
 
3066 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3067 
    """
3068 
    Parameters:
3069 
     - catalog_item_id
3070 
     - voucherType
3071 
     - voucherAmount
3072 
    """
3073 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3074 
    return self.recv_addupdateVoucherForItem()
3075 
 
3076 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3077 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3078 
    args = addupdateVoucherForItem_args()
3079 
    args.catalog_item_id = catalog_item_id
3080 
    args.voucherType = voucherType
3081 
    args.voucherAmount = voucherAmount
3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_addupdateVoucherForItem(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = addupdateVoucherForItem_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3096 
    if result.success is not None:
3097 
      return result.success
3098 
    if result.cex is not None:
3099 
      raise result.cex
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3101 
 
3102 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3103 
    """
3104 
    Parameters:
3105 
     - catalog_item_id
3106 
     - voucherType
3107 
    """
3108 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3109 
    return self.recv_deleteVoucherForItem()
3110 
 
3111 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3112 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3113 
    args = deleteVoucherForItem_args()
3114 
    args.catalog_item_id = catalog_item_id
3115 
    args.voucherType = voucherType
3116 
    args.write(self._oprot)
3117 
    self._oprot.writeMessageEnd()
3118 
    self._oprot.trans.flush()
3119 
 
3120 
  def recv_deleteVoucherForItem(self, ):
3121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3122 
    if mtype == TMessageType.EXCEPTION:
3123 
      x = TApplicationException()
3124 
      x.read(self._iprot)
3125 
      self._iprot.readMessageEnd()
3126 
      raise x
3127 
    result = deleteVoucherForItem_result()
3128 
    result.read(self._iprot)
3129 
    self._iprot.readMessageEnd()
3130 
    if result.success is not None:
3131 
      return result.success
3132 
    if result.cex is not None:
3133 
      raise result.cex
3134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3135 
 
3136 
  def getVoucherAmount(self, itemId, voucherType):
3137 
    """
3138 
    Parameters:
3139 
     - itemId
3140 
     - voucherType
3141 
    """
3142 
    self.send_getVoucherAmount(itemId, voucherType)
3143 
    return self.recv_getVoucherAmount()
3144 
 
3145 
  def send_getVoucherAmount(self, itemId, voucherType):
3146 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3147 
    args = getVoucherAmount_args()
3148 
    args.itemId = itemId
3149 
    args.voucherType = voucherType
3150 
    args.write(self._oprot)
3151 
    self._oprot.writeMessageEnd()
3152 
    self._oprot.trans.flush()
3153 
 
3154 
  def recv_getVoucherAmount(self, ):
3155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3156 
    if mtype == TMessageType.EXCEPTION:
3157 
      x = TApplicationException()
3158 
      x.read(self._iprot)
3159 
      self._iprot.readMessageEnd()
3160 
      raise x
3161 
    result = getVoucherAmount_result()
3162 
    result.read(self._iprot)
3163 
    self._iprot.readMessageEnd()
3164 
    if result.success is not None:
3165 
      return result.success
3166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3167 
 
3168 
  def getAllItemVouchers(self, itemId):
3169 
    """
3170 
    Parameters:
3171 
     - itemId
3172 
    """
3173 
    self.send_getAllItemVouchers(itemId)
3174 
    return self.recv_getAllItemVouchers()
3175 
 
3176 
  def send_getAllItemVouchers(self, itemId):
3177 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3178 
    args = getAllItemVouchers_args()
3179 
    args.itemId = itemId
3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_getAllItemVouchers(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = getAllItemVouchers_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    if result.success is not None:
3195 
      return result.success
3196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3197 
 
3198 
  def isValidCatalogItemId(self, catalog_item_id):
3199 
    """
3200 
    Parameters:
3201 
     - catalog_item_id
3202 
    """
3203 
    self.send_isValidCatalogItemId(catalog_item_id)
3204 
    return self.recv_isValidCatalogItemId()
3205 
 
3206 
  def send_isValidCatalogItemId(self, catalog_item_id):
3207 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3208 
    args = isValidCatalogItemId_args()
3209 
    args.catalog_item_id = catalog_item_id
3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_isValidCatalogItemId(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = isValidCatalogItemId_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3224 
    if result.success is not None:
3225 
      return result.success
3226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3227 
 
7330 amit.gupta 3228 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3229 
    """
3230 
    Parameters:
3231 
     - itemId
7330 amit.gupta 3232 
     - stateId
6039 amit.gupta 3233 
     - price
3234 
    """
7330 amit.gupta 3235 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3236 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3237 
 
7330 amit.gupta 3238 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3239 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3240 
    args = getVatPercentageForItem_args()
3241 
    args.itemId = itemId
7330 amit.gupta 3242 
    args.stateId = stateId
6039 amit.gupta 3243 
    args.price = price
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_getVatPercentageForItem(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = getVatPercentageForItem_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    if result.success is not None:
3259 
      return result.success
7340 amit.gupta 3260 
    if result.cex is not None:
3261 
      raise result.cex
6039 amit.gupta 3262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3263 
 
3264 
  def getVatAmountForItem(self, itemId, price):
3265 
    """
3266 
    Parameters:
3267 
     - itemId
3268 
     - price
3269 
    """
3270 
    self.send_getVatAmountForItem(itemId, price)
3271 
    return self.recv_getVatAmountForItem()
3272 
 
3273 
  def send_getVatAmountForItem(self, itemId, price):
3274 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3275 
    args = getVatAmountForItem_args()
3276 
    args.itemId = itemId
3277 
    args.price = price
3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_getVatAmountForItem(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = getVatAmountForItem_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.success is not None:
3293 
      return result.success
3294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3295 
 
6531 vikram.rag 3296 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3297 
    """
3298 
    Parameters:
3299 
     - offset
3300 
     - limit
3301 
    """
3302 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3303 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3304 
 
6531 vikram.rag 3305 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3306 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3307 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3308 
    args.offset = offset
3309 
    args.limit = limit
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
3324 
    if result.success is not None:
3325 
      return result.success
3326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3327 
 
6821 amar.kumar 3328 
  def getAllAliveItems(self, ):
3329 
    self.send_getAllAliveItems()
3330 
    return self.recv_getAllAliveItems()
3331 
 
3332 
  def send_getAllAliveItems(self, ):
3333 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3334 
    args = getAllAliveItems_args()
3335 
    args.write(self._oprot)
3336 
    self._oprot.writeMessageEnd()
3337 
    self._oprot.trans.flush()
3338 
 
3339 
  def recv_getAllAliveItems(self, ):
3340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3341 
    if mtype == TMessageType.EXCEPTION:
3342 
      x = TApplicationException()
3343 
      x.read(self._iprot)
3344 
      self._iprot.readMessageEnd()
3345 
      raise x
3346 
    result = getAllAliveItems_result()
3347 
    result.read(self._iprot)
3348 
    self._iprot.readMessageEnd()
3349 
    if result.success is not None:
3350 
      return result.success
3351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3352 
 
6921 anupam.sin 3353 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3354 
    """
3355 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3356 
 
6805 anupam.sin 3357 
    Parameters:
3358 
     - itemId
6921 anupam.sin 3359 
     - price
6805 anupam.sin 3360 
     - insurerId
3361 
     - quantity
3362 
    """
6921 anupam.sin 3363 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3364 
    return self.recv_getInsuranceAmount()
3365 
 
6921 anupam.sin 3366 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3367 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3368 
    args = getInsuranceAmount_args()
3369 
    args.itemId = itemId
6921 anupam.sin 3370 
    args.price = price
6805 anupam.sin 3371 
    args.insurerId = insurerId
3372 
    args.quantity = quantity
3373 
    args.write(self._oprot)
3374 
    self._oprot.writeMessageEnd()
3375 
    self._oprot.trans.flush()
3376 
 
3377 
  def recv_getInsuranceAmount(self, ):
3378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3379 
    if mtype == TMessageType.EXCEPTION:
3380 
      x = TApplicationException()
3381 
      x.read(self._iprot)
3382 
      self._iprot.readMessageEnd()
3383 
      raise x
3384 
    result = getInsuranceAmount_result()
3385 
    result.read(self._iprot)
3386 
    self._iprot.readMessageEnd()
3387 
    if result.success is not None:
3388 
      return result.success
3389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3390 
 
3391 
  def getInsurer(self, insurerId):
3392 
    """
3393 
    Parameters:
3394 
     - insurerId
3395 
    """
3396 
    self.send_getInsurer(insurerId)
3397 
    return self.recv_getInsurer()
3398 
 
3399 
  def send_getInsurer(self, insurerId):
3400 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3401 
    args = getInsurer_args()
3402 
    args.insurerId = insurerId
3403 
    args.write(self._oprot)
3404 
    self._oprot.writeMessageEnd()
3405 
    self._oprot.trans.flush()
3406 
 
3407 
  def recv_getInsurer(self, ):
3408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3409 
    if mtype == TMessageType.EXCEPTION:
3410 
      x = TApplicationException()
3411 
      x.read(self._iprot)
3412 
      self._iprot.readMessageEnd()
3413 
      raise x
3414 
    result = getInsurer_result()
3415 
    result.read(self._iprot)
3416 
    self._iprot.readMessageEnd()
3417 
    if result.success is not None:
3418 
      return result.success
3419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3420 
 
6838 vikram.rag 3421 
  def getAllInsurers(self, ):
3422 
    self.send_getAllInsurers()
3423 
    return self.recv_getAllInsurers()
6805 anupam.sin 3424 
 
6838 vikram.rag 3425 
  def send_getAllInsurers(self, ):
3426 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3427 
    args = getAllInsurers_args()
3428 
    args.write(self._oprot)
3429 
    self._oprot.writeMessageEnd()
3430 
    self._oprot.trans.flush()
3431 
 
3432 
  def recv_getAllInsurers(self, ):
3433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3434 
    if mtype == TMessageType.EXCEPTION:
3435 
      x = TApplicationException()
3436 
      x.read(self._iprot)
3437 
      self._iprot.readMessageEnd()
3438 
      raise x
3439 
    result = getAllInsurers_result()
3440 
    result.read(self._iprot)
3441 
    self._iprot.readMessageEnd()
3442 
    if result.success is not None:
3443 
      return result.success
3444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3445 
 
6962 rajveer 3446 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3447 
    """
3448 
    Parameters:
3449 
     - insurerId
3450 
     - amount
3451 
    """
3452 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3453 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3454 
 
6962 rajveer 3455 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3456 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3457 
    args = updateInsuranceDeclaredAmount_args()
3458 
    args.insurerId = insurerId
3459 
    args.amount = amount
3460 
    args.write(self._oprot)
3461 
    self._oprot.writeMessageEnd()
3462 
    self._oprot.trans.flush()
3463 
 
3464 
  def recv_updateInsuranceDeclaredAmount(self, ):
3465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3466 
    if mtype == TMessageType.EXCEPTION:
3467 
      x = TApplicationException()
3468 
      x.read(self._iprot)
3469 
      self._iprot.readMessageEnd()
3470 
      raise x
3471 
    result = updateInsuranceDeclaredAmount_result()
3472 
    result.read(self._iprot)
3473 
    self._iprot.readMessageEnd()
3474 
    return
3475 
 
7190 amar.kumar 3476 
  def getFreebieForItem(self, itemId):
3477 
    """
3478 
    Parameters:
3479 
     - itemId
3480 
    """
3481 
    self.send_getFreebieForItem(itemId)
3482 
    return self.recv_getFreebieForItem()
6962 rajveer 3483 
 
7190 amar.kumar 3484 
  def send_getFreebieForItem(self, itemId):
3485 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3486 
    args = getFreebieForItem_args()
3487 
    args.itemId = itemId
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_getFreebieForItem(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = getFreebieForItem_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3502 
    if result.success is not None:
3503 
      return result.success
3504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3505 
 
3506 
  def addOrUpdateFreebieForItem(self, freebieItem):
3507 
    """
3508 
    Parameters:
3509 
     - freebieItem
3510 
    """
3511 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3512 
    self.recv_addOrUpdateFreebieForItem()
3513 
 
3514 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3515 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3516 
    args = addOrUpdateFreebieForItem_args()
3517 
    args.freebieItem = freebieItem
3518 
    args.write(self._oprot)
3519 
    self._oprot.writeMessageEnd()
3520 
    self._oprot.trans.flush()
3521 
 
3522 
  def recv_addOrUpdateFreebieForItem(self, ):
3523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3524 
    if mtype == TMessageType.EXCEPTION:
3525 
      x = TApplicationException()
3526 
      x.read(self._iprot)
3527 
      self._iprot.readMessageEnd()
3528 
      raise x
3529 
    result = addOrUpdateFreebieForItem_result()
3530 
    result.read(self._iprot)
3531 
    self._iprot.readMessageEnd()
3532 
    return
3533 
 
7272 amit.gupta 3534 
  def addOrUpdateBrandInfo(self, brandInfo):
3535 
    """
3536 
    Parameters:
3537 
     - brandInfo
3538 
    """
3539 
    self.send_addOrUpdateBrandInfo(brandInfo)
3540 
    self.recv_addOrUpdateBrandInfo()
3541 
 
3542 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3543 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3544 
    args = addOrUpdateBrandInfo_args()
3545 
    args.brandInfo = brandInfo
3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_addOrUpdateBrandInfo(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = addOrUpdateBrandInfo_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3560 
    return
3561 
 
3562 
  def getBrandInfo(self, ):
3563 
    self.send_getBrandInfo()
3564 
    return self.recv_getBrandInfo()
3565 
 
3566 
  def send_getBrandInfo(self, ):
3567 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3568 
    args = getBrandInfo_args()
3569 
    args.write(self._oprot)
3570 
    self._oprot.writeMessageEnd()
3571 
    self._oprot.trans.flush()
3572 
 
3573 
  def recv_getBrandInfo(self, ):
3574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3575 
    if mtype == TMessageType.EXCEPTION:
3576 
      x = TApplicationException()
3577 
      x.read(self._iprot)
3578 
      self._iprot.readMessageEnd()
3579 
      raise x
3580 
    result = getBrandInfo_result()
3581 
    result.read(self._iprot)
3582 
    self._iprot.readMessageEnd()
3583 
    if result.success is not None:
3584 
      return result.success
3585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3586 
 
7256 rajveer 3587 
  def getStorePricing(self, itemId):
3588 
    """
3589 
    Parameters:
3590 
     - itemId
3591 
    """
3592 
    self.send_getStorePricing(itemId)
3593 
    return self.recv_getStorePricing()
7190 amar.kumar 3594 
 
7256 rajveer 3595 
  def send_getStorePricing(self, itemId):
3596 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3597 
    args = getStorePricing_args()
3598 
    args.itemId = itemId
3599 
    args.write(self._oprot)
3600 
    self._oprot.writeMessageEnd()
3601 
    self._oprot.trans.flush()
3602 
 
3603 
  def recv_getStorePricing(self, ):
3604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3605 
    if mtype == TMessageType.EXCEPTION:
3606 
      x = TApplicationException()
3607 
      x.read(self._iprot)
3608 
      self._iprot.readMessageEnd()
3609 
      raise x
3610 
    result = getStorePricing_result()
3611 
    result.read(self._iprot)
3612 
    self._iprot.readMessageEnd()
3613 
    if result.success is not None:
3614 
      return result.success
3615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3616 
 
7306 rajveer 3617 
  def getStorePricings(self, itemIds):
3618 
    """
3619 
    Parameters:
3620 
     - itemIds
3621 
    """
3622 
    self.send_getStorePricings(itemIds)
3623 
    return self.recv_getStorePricings()
3624 
 
3625 
  def send_getStorePricings(self, itemIds):
3626 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3627 
    args = getStorePricings_args()
3628 
    args.itemIds = itemIds
3629 
    args.write(self._oprot)
3630 
    self._oprot.writeMessageEnd()
3631 
    self._oprot.trans.flush()
3632 
 
3633 
  def recv_getStorePricings(self, ):
3634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3635 
    if mtype == TMessageType.EXCEPTION:
3636 
      x = TApplicationException()
3637 
      x.read(self._iprot)
3638 
      self._iprot.readMessageEnd()
3639 
      raise x
3640 
    result = getStorePricings_result()
3641 
    result.read(self._iprot)
3642 
    self._iprot.readMessageEnd()
3643 
    if result.success is not None:
3644 
      return result.success
3645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3646 
 
7382 rajveer 3647 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3648 
    """
3649 
    Parameters:
3650 
     - sp
7382 rajveer 3651 
     - allColors
7265 rajveer 3652 
    """
7382 rajveer 3653 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3654 
    self.recv_updateStorePricing()
7256 rajveer 3655 
 
7382 rajveer 3656 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3657 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3658 
    args = updateStorePricing_args()
3659 
    args.sp = sp
7382 rajveer 3660 
    args.allColors = allColors
7265 rajveer 3661 
    args.write(self._oprot)
3662 
    self._oprot.writeMessageEnd()
3663 
    self._oprot.trans.flush()
3664 
 
3665 
  def recv_updateStorePricing(self, ):
3666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3667 
    if mtype == TMessageType.EXCEPTION:
3668 
      x = TApplicationException()
3669 
      x.read(self._iprot)
3670 
      self._iprot.readMessageEnd()
3671 
      raise x
3672 
    result = updateStorePricing_result()
3673 
    result.read(self._iprot)
3674 
    self._iprot.readMessageEnd()
3675 
    return
3676 
 
7281 kshitij.so 3677 
  def getAllAmazonListedItems(self, ):
3678 
    self.send_getAllAmazonListedItems()
3679 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3680 
 
7281 kshitij.so 3681 
  def send_getAllAmazonListedItems(self, ):
3682 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3683 
    args = getAllAmazonListedItems_args()
3684 
    args.write(self._oprot)
3685 
    self._oprot.writeMessageEnd()
3686 
    self._oprot.trans.flush()
3687 
 
3688 
  def recv_getAllAmazonListedItems(self, ):
3689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3690 
    if mtype == TMessageType.EXCEPTION:
3691 
      x = TApplicationException()
3692 
      x.read(self._iprot)
3693 
      self._iprot.readMessageEnd()
3694 
      raise x
3695 
    result = getAllAmazonListedItems_result()
3696 
    result.read(self._iprot)
3697 
    self._iprot.readMessageEnd()
3698 
    if result.success is not None:
3699 
      return result.success
3700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3701 
 
3702 
  def getAmazonItemDetails(self, itemId):
3703 
    """
3704 
    Parameters:
3705 
     - itemId
3706 
    """
3707 
    self.send_getAmazonItemDetails(itemId)
3708 
    return self.recv_getAmazonItemDetails()
3709 
 
3710 
  def send_getAmazonItemDetails(self, itemId):
3711 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3712 
    args = getAmazonItemDetails_args()
3713 
    args.itemId = itemId
3714 
    args.write(self._oprot)
3715 
    self._oprot.writeMessageEnd()
3716 
    self._oprot.trans.flush()
3717 
 
3718 
  def recv_getAmazonItemDetails(self, ):
3719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3720 
    if mtype == TMessageType.EXCEPTION:
3721 
      x = TApplicationException()
3722 
      x.read(self._iprot)
3723 
      self._iprot.readMessageEnd()
3724 
      raise x
3725 
    result = getAmazonItemDetails_result()
3726 
    result.read(self._iprot)
3727 
    self._iprot.readMessageEnd()
3728 
    if result.success is not None:
3729 
      return result.success
3730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3731 
 
8168 kshitij.so 3732 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 3733 
    """
3734 
    Parameters:
8168 kshitij.so 3735 
     - amazonlisted
7281 kshitij.so 3736 
    """
8168 kshitij.so 3737 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 3738 
    self.recv_updateAmazonItemDetails()
3739 
 
8168 kshitij.so 3740 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 3741 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3742 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 3743 
    args.amazonlisted = amazonlisted
7281 kshitij.so 3744 
    args.write(self._oprot)
3745 
    self._oprot.writeMessageEnd()
3746 
    self._oprot.trans.flush()
3747 
 
3748 
  def recv_updateAmazonItemDetails(self, ):
3749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3750 
    if mtype == TMessageType.EXCEPTION:
3751 
      x = TApplicationException()
3752 
      x.read(self._iprot)
3753 
      self._iprot.readMessageEnd()
3754 
      raise x
3755 
    result = updateAmazonItemDetails_result()
3756 
    result.read(self._iprot)
3757 
    self._iprot.readMessageEnd()
3758 
    return
3759 
 
3760 
  def addAmazonItem(self, amazonlisted):
3761 
    """
3762 
    Parameters:
3763 
     - amazonlisted
3764 
    """
3765 
    self.send_addAmazonItem(amazonlisted)
3766 
    self.recv_addAmazonItem()
3767 
 
3768 
  def send_addAmazonItem(self, amazonlisted):
3769 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3770 
    args = addAmazonItem_args()
3771 
    args.amazonlisted = amazonlisted
3772 
    args.write(self._oprot)
3773 
    self._oprot.writeMessageEnd()
3774 
    self._oprot.trans.flush()
3775 
 
3776 
  def recv_addAmazonItem(self, ):
3777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3778 
    if mtype == TMessageType.EXCEPTION:
3779 
      x = TApplicationException()
3780 
      x.read(self._iprot)
3781 
      self._iprot.readMessageEnd()
3782 
      raise x
3783 
    result = addAmazonItem_result()
3784 
    result.read(self._iprot)
3785 
    self._iprot.readMessageEnd()
3786 
    return
3787 
 
7291 vikram.rag 3788 
  def getAsinItems(self, ):
3789 
    self.send_getAsinItems()
3790 
    return self.recv_getAsinItems()
7281 kshitij.so 3791 
 
7291 vikram.rag 3792 
  def send_getAsinItems(self, ):
3793 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3794 
    args = getAsinItems_args()
3795 
    args.write(self._oprot)
3796 
    self._oprot.writeMessageEnd()
3797 
    self._oprot.trans.flush()
3798 
 
3799 
  def recv_getAsinItems(self, ):
3800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3801 
    if mtype == TMessageType.EXCEPTION:
3802 
      x = TApplicationException()
3803 
      x.read(self._iprot)
3804 
      self._iprot.readMessageEnd()
3805 
      raise x
3806 
    result = getAsinItems_result()
3807 
    result.read(self._iprot)
3808 
    self._iprot.readMessageEnd()
3809 
    if result.success is not None:
3810 
      return result.success
3811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3812 
 
3813 
  def getAllFbaListedItems(self, ):
3814 
    self.send_getAllFbaListedItems()
3815 
    return self.recv_getAllFbaListedItems()
3816 
 
3817 
  def send_getAllFbaListedItems(self, ):
3818 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3819 
    args = getAllFbaListedItems_args()
3820 
    args.write(self._oprot)
3821 
    self._oprot.writeMessageEnd()
3822 
    self._oprot.trans.flush()
3823 
 
3824 
  def recv_getAllFbaListedItems(self, ):
3825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3826 
    if mtype == TMessageType.EXCEPTION:
3827 
      x = TApplicationException()
3828 
      x.read(self._iprot)
3829 
      self._iprot.readMessageEnd()
3830 
      raise x
3831 
    result = getAllFbaListedItems_result()
3832 
    result.read(self._iprot)
3833 
    self._iprot.readMessageEnd()
3834 
    if result.success is not None:
3835 
      return result.success
3836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3837 
 
3838 
  def getAllNonFbaListedItems(self, ):
3839 
    self.send_getAllNonFbaListedItems()
3840 
    return self.recv_getAllNonFbaListedItems()
3841 
 
3842 
  def send_getAllNonFbaListedItems(self, ):
3843 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3844 
    args = getAllNonFbaListedItems_args()
3845 
    args.write(self._oprot)
3846 
    self._oprot.writeMessageEnd()
3847 
    self._oprot.trans.flush()
3848 
 
3849 
  def recv_getAllNonFbaListedItems(self, ):
3850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3851 
    if mtype == TMessageType.EXCEPTION:
3852 
      x = TApplicationException()
3853 
      x.read(self._iprot)
3854 
      self._iprot.readMessageEnd()
3855 
      raise x
3856 
    result = getAllNonFbaListedItems_result()
3857 
    result.read(self._iprot)
3858 
    self._iprot.readMessageEnd()
3859 
    if result.success is not None:
3860 
      return result.success
3861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3862 
 
7460 kshitij.so 3863 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3864 
    """
3865 
    Parameters:
3866 
     - itemId
3867 
     - holdInventory
3868 
     - defaultInventory
3869 
    """
3870 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3871 
    return self.recv_updateItemInventory()
7291 vikram.rag 3872 
 
7460 kshitij.so 3873 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3874 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3875 
    args = updateItemInventory_args()
3876 
    args.itemId = itemId
3877 
    args.holdInventory = holdInventory
3878 
    args.defaultInventory = defaultInventory
3879 
    args.write(self._oprot)
3880 
    self._oprot.writeMessageEnd()
3881 
    self._oprot.trans.flush()
3882 
 
3883 
  def recv_updateItemInventory(self, ):
3884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3885 
    if mtype == TMessageType.EXCEPTION:
3886 
      x = TApplicationException()
3887 
      x.read(self._iprot)
3888 
      self._iprot.readMessageEnd()
3889 
      raise x
3890 
    result = updateItemInventory_result()
3891 
    result.read(self._iprot)
3892 
    self._iprot.readMessageEnd()
3893 
    if result.success is not None:
3894 
      return result.success
3895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3896 
 
7770 kshitij.so 3897 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3898 
    """
3899 
    Parameters:
3900 
     - type
3901 
     - sku
3902 
     - timestamp
3903 
    """
3904 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3905 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3906 
 
7770 kshitij.so 3907 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3908 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3909 
    args = updateTimestampForAmazonFeeds_args()
3910 
    args.type = type
3911 
    args.sku = sku
3912 
    args.timestamp = timestamp
3913 
    args.write(self._oprot)
3914 
    self._oprot.writeMessageEnd()
3915 
    self._oprot.trans.flush()
3916 
 
3917 
  def recv_updateTimestampForAmazonFeeds(self, ):
3918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3919 
    if mtype == TMessageType.EXCEPTION:
3920 
      x = TApplicationException()
3921 
      x.read(self._iprot)
3922 
      self._iprot.readMessageEnd()
3923 
      raise x
3924 
    result = updateTimestampForAmazonFeeds_result()
3925 
    result.read(self._iprot)
3926 
    self._iprot.readMessageEnd()
3927 
    if result.success is not None:
3928 
      return result.success
3929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3930 
 
7897 amar.kumar 3931 
  def getAllParentCategories(self, ):
3932 
    self.send_getAllParentCategories()
3933 
    return self.recv_getAllParentCategories()
7770 kshitij.so 3934 
 
7897 amar.kumar 3935 
  def send_getAllParentCategories(self, ):
3936 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
3937 
    args = getAllParentCategories_args()
3938 
    args.write(self._oprot)
3939 
    self._oprot.writeMessageEnd()
3940 
    self._oprot.trans.flush()
3941 
 
3942 
  def recv_getAllParentCategories(self, ):
3943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3944 
    if mtype == TMessageType.EXCEPTION:
3945 
      x = TApplicationException()
3946 
      x.read(self._iprot)
3947 
      self._iprot.readMessageEnd()
3948 
      raise x
3949 
    result = getAllParentCategories_result()
3950 
    result.read(self._iprot)
3951 
    self._iprot.readMessageEnd()
3952 
    if result.success is not None:
3953 
      return result.success
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
3955 
 
7977 kshitij.so 3956 
  def addPageViewEvent(self, pageViewEvents):
3957 
    """
3958 
    Parameters:
3959 
     - pageViewEvents
3960 
    """
3961 
    self.send_addPageViewEvent(pageViewEvents)
3962 
    self.recv_addPageViewEvent()
7897 amar.kumar 3963 
 
7977 kshitij.so 3964 
  def send_addPageViewEvent(self, pageViewEvents):
3965 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
3966 
    args = addPageViewEvent_args()
3967 
    args.pageViewEvents = pageViewEvents
3968 
    args.write(self._oprot)
3969 
    self._oprot.writeMessageEnd()
3970 
    self._oprot.trans.flush()
3971 
 
3972 
  def recv_addPageViewEvent(self, ):
3973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3974 
    if mtype == TMessageType.EXCEPTION:
3975 
      x = TApplicationException()
3976 
      x.read(self._iprot)
3977 
      self._iprot.readMessageEnd()
3978 
      raise x
3979 
    result = addPageViewEvent_result()
3980 
    result.read(self._iprot)
3981 
    self._iprot.readMessageEnd()
3982 
    return
3983 
 
3984 
  def addCartEvent(self, cartEvents):
3985 
    """
3986 
    Parameters:
3987 
     - cartEvents
3988 
    """
3989 
    self.send_addCartEvent(cartEvents)
3990 
    self.recv_addCartEvent()
3991 
 
3992 
  def send_addCartEvent(self, cartEvents):
3993 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
3994 
    args = addCartEvent_args()
3995 
    args.cartEvents = cartEvents
3996 
    args.write(self._oprot)
3997 
    self._oprot.writeMessageEnd()
3998 
    self._oprot.trans.flush()
3999 
 
4000 
  def recv_addCartEvent(self, ):
4001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4002 
    if mtype == TMessageType.EXCEPTION:
4003 
      x = TApplicationException()
4004 
      x.read(self._iprot)
4005 
      self._iprot.readMessageEnd()
4006 
      raise x
4007 
    result = addCartEvent_result()
4008 
    result.read(self._iprot)
4009 
    self._iprot.readMessageEnd()
4010 
    return
4011 
 
8182 amar.kumar 4012 
  def addEbayItem(self, ebayItem):
4013 
    """
4014 
    Parameters:
4015 
     - ebayItem
4016 
    """
4017 
    self.send_addEbayItem(ebayItem)
4018 
    self.recv_addEbayItem()
4019 
 
4020 
  def send_addEbayItem(self, ebayItem):
4021 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4022 
    args = addEbayItem_args()
4023 
    args.ebayItem = ebayItem
4024 
    args.write(self._oprot)
4025 
    self._oprot.writeMessageEnd()
4026 
    self._oprot.trans.flush()
4027 
 
4028 
  def recv_addEbayItem(self, ):
4029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4030 
    if mtype == TMessageType.EXCEPTION:
4031 
      x = TApplicationException()
4032 
      x.read(self._iprot)
4033 
      self._iprot.readMessageEnd()
4034 
      raise x
4035 
    result = addEbayItem_result()
4036 
    result.read(self._iprot)
4037 
    self._iprot.readMessageEnd()
4038 
    return
4039 
 
4040 
  def getEbayItem(self, listingId):
4041 
    """
4042 
    Parameters:
4043 
     - listingId
4044 
    """
4045 
    self.send_getEbayItem(listingId)
4046 
    return self.recv_getEbayItem()
4047 
 
4048 
  def send_getEbayItem(self, listingId):
4049 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4050 
    args = getEbayItem_args()
4051 
    args.listingId = listingId
4052 
    args.write(self._oprot)
4053 
    self._oprot.writeMessageEnd()
4054 
    self._oprot.trans.flush()
4055 
 
4056 
  def recv_getEbayItem(self, ):
4057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4058 
    if mtype == TMessageType.EXCEPTION:
4059 
      x = TApplicationException()
4060 
      x.read(self._iprot)
4061 
      self._iprot.readMessageEnd()
4062 
      raise x
4063 
    result = getEbayItem_result()
4064 
    result.read(self._iprot)
4065 
    self._iprot.readMessageEnd()
4066 
    if result.success is not None:
4067 
      return result.success
4068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4069 
 
4070 
  def updateEbayItem(self, ebayItem):
4071 
    """
4072 
    Parameters:
4073 
     - ebayItem
4074 
    """
4075 
    self.send_updateEbayItem(ebayItem)
4076 
    self.recv_updateEbayItem()
4077 
 
4078 
  def send_updateEbayItem(self, ebayItem):
4079 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4080 
    args = updateEbayItem_args()
4081 
    args.ebayItem = ebayItem
4082 
    args.write(self._oprot)
4083 
    self._oprot.writeMessageEnd()
4084 
    self._oprot.trans.flush()
4085 
 
4086 
  def recv_updateEbayItem(self, ):
4087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4088 
    if mtype == TMessageType.EXCEPTION:
4089 
      x = TApplicationException()
4090 
      x.read(self._iprot)
4091 
      self._iprot.readMessageEnd()
4092 
      raise x
4093 
    result = updateEbayItem_result()
4094 
    result.read(self._iprot)
4095 
    self._iprot.readMessageEnd()
4096 
    return
4097 
 
8139 kshitij.so 4098 
  def getAmazonListedItems(self, offset, limit):
4099 
    """
4100 
    Parameters:
4101 
     - offset
4102 
     - limit
4103 
    """
4104 
    self.send_getAmazonListedItems(offset, limit)
4105 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4106 
 
8139 kshitij.so 4107 
  def send_getAmazonListedItems(self, offset, limit):
4108 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4109 
    args = getAmazonListedItems_args()
4110 
    args.offset = offset
4111 
    args.limit = limit
4112 
    args.write(self._oprot)
4113 
    self._oprot.writeMessageEnd()
4114 
    self._oprot.trans.flush()
4115 
 
4116 
  def recv_getAmazonListedItems(self, ):
4117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4118 
    if mtype == TMessageType.EXCEPTION:
4119 
      x = TApplicationException()
4120 
      x.read(self._iprot)
4121 
      self._iprot.readMessageEnd()
4122 
      raise x
4123 
    result = getAmazonListedItems_result()
4124 
    result.read(self._iprot)
4125 
    self._iprot.readMessageEnd()
4126 
    if result.success is not None:
4127 
      return result.success
4128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4129 
 
8168 kshitij.so 4130 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4131 
    """
4132 
    Parameters:
4133 
     - amazonlisted
4134 
    """
4135 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4136 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4137 
 
8168 kshitij.so 4138 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4139 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4140 
    args = updateAmazonAttributesInBulk_args()
4141 
    args.amazonlisted = amazonlisted
4142 
    args.write(self._oprot)
4143 
    self._oprot.writeMessageEnd()
4144 
    self._oprot.trans.flush()
4145 
 
4146 
  def recv_updateAmazonAttributesInBulk(self, ):
4147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4148 
    if mtype == TMessageType.EXCEPTION:
4149 
      x = TApplicationException()
4150 
      x.read(self._iprot)
4151 
      self._iprot.readMessageEnd()
4152 
      raise x
4153 
    result = updateAmazonAttributesInBulk_result()
4154 
    result.read(self._iprot)
4155 
    self._iprot.readMessageEnd()
4156 
    if result.success is not None:
4157 
      return result.success
4158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4159 
 
4160 
 
5944 mandeep.dh 4161 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4162 
  def __init__(self, handler):
4163 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4164 
    self._processMap["addItem"] = Processor.process_addItem
4165 
    self._processMap["updateItem"] = Processor.process_updateItem
4166 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4167 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4168 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4169 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4170 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4171 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4172 
    self._processMap["getItem"] = Processor.process_getItem
4173 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4174 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4175 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4176 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4177 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4178 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4179 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4180 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4181 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4182 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4183 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4184 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4185 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4186 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4187 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4188 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4189 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4190 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4191 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4192 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4193 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4194 
    self._processMap["addCategory"] = Processor.process_addCategory
4195 
    self._processMap["getCategory"] = Processor.process_getCategory
4196 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4197 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4198 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4199 
    self._processMap["addTag"] = Processor.process_addTag
4200 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4201 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4202 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4203 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4204 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4205 
    self._processMap["addBanner"] = Processor.process_addBanner
4206 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4207 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4208 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4209 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4210 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
4211 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4212 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 4213 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4214 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4215 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4216 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4217 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4218 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4219 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4220 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4221 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4222 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4223 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4224 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4225 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4226 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4227 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4228 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4229 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4230 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4231 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4232 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4233 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4234 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4235 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4236 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4237 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4238 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4239 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4240 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4241 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4242 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4243 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4244 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4245 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4246 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4247 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4248 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4249 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4250 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4251 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4252 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4253 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4254 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4255 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4256 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4257 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4258 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4259 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4260 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4261 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4262 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4263 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4264 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4265 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4266 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4267 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4268 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4269 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4270 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
5944 mandeep.dh 4271 
 
4272 
  def process(self, iprot, oprot):
4273 
    (name, type, seqid) = iprot.readMessageBegin()
4274 
    if name not in self._processMap:
4275 
      iprot.skip(TType.STRUCT)
4276 
      iprot.readMessageEnd()
4277 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4278 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4279 
      x.write(oprot)
4280 
      oprot.writeMessageEnd()
4281 
      oprot.trans.flush()
4282 
      return
4283 
    else:
4284 
      self._processMap[name](self, seqid, iprot, oprot)
4285 
    return True
4286 
 
4287 
  def process_addItem(self, seqid, iprot, oprot):
4288 
    args = addItem_args()
4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
4291 
    result = addItem_result()
4292 
    try:
4293 
      result.success = self._handler.addItem(args.item)
4294 
    except CatalogServiceException, cex:
4295 
      result.cex = cex
4296 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
4300 
 
4301 
  def process_updateItem(self, seqid, iprot, oprot):
4302 
    args = updateItem_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    result = updateItem_result()
4306 
    try:
4307 
      result.success = self._handler.updateItem(args.item)
4308 
    except CatalogServiceException, cex:
4309 
      result.cex = cex
4310 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4311 
    result.write(oprot)
4312 
    oprot.writeMessageEnd()
4313 
    oprot.trans.flush()
4314 
 
4315 
  def process_isActive(self, seqid, iprot, oprot):
4316 
    args = isActive_args()
4317 
    args.read(iprot)
4318 
    iprot.readMessageEnd()
4319 
    result = isActive_result()
4320 
    try:
4321 
      result.success = self._handler.isActive(args.itemId)
4322 
    except CatalogServiceException, isex:
4323 
      result.isex = isex
4324 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4325 
    result.write(oprot)
4326 
    oprot.writeMessageEnd()
4327 
    oprot.trans.flush()
4328 
 
7438 amit.gupta 4329 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4330 
    args = getItemsStatus_args()
4331 
    args.read(iprot)
4332 
    iprot.readMessageEnd()
4333 
    result = getItemsStatus_result()
4334 
    try:
4335 
      result.success = self._handler.getItemsStatus(args.itemIds)
4336 
    except CatalogServiceException, isex:
4337 
      result.isex = isex
4338 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4342 
 
5944 mandeep.dh 4343 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4344 
    args = getItemStatusDescription_args()
4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
4347 
    result = getItemStatusDescription_result()
4348 
    try:
4349 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4350 
    except CatalogServiceException, isex:
4351 
      result.isex = isex
4352 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
4356 
 
4357 
  def process_startItemOn(self, seqid, iprot, oprot):
4358 
    args = startItemOn_args()
4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
4361 
    result = startItemOn_result()
4362 
    try:
4363 
      self._handler.startItemOn(args.item_id, args.timestamp)
4364 
    except CatalogServiceException, cex:
4365 
      result.cex = cex
4366 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
4370 
 
4371 
  def process_retireItemOn(self, seqid, iprot, oprot):
4372 
    args = retireItemOn_args()
4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
4375 
    result = retireItemOn_result()
4376 
    try:
4377 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4378 
    except CatalogServiceException, cex:
4379 
      result.cex = cex
4380 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
4385 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4386 
    args = changeItemStatus_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = changeItemStatus_result()
4390 
    try:
4391 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4392 
    except CatalogServiceException, cex:
4393 
      result.cex = cex
4394 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
4398 
 
4399 
  def process_getItem(self, seqid, iprot, oprot):
4400 
    args = getItem_args()
4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
4403 
    result = getItem_result()
4404 
    try:
4405 
      result.success = self._handler.getItem(args.item_id)
4406 
    except CatalogServiceException, cex:
4407 
      result.cex = cex
4408 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
4412 
 
4413 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4414 
    args = getItemsByCatalogId_args()
4415 
    args.read(iprot)
4416 
    iprot.readMessageEnd()
4417 
    result = getItemsByCatalogId_result()
4418 
    try:
4419 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4420 
    except CatalogServiceException, cex:
4421 
      result.cex = cex
4422 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4423 
    result.write(oprot)
4424 
    oprot.writeMessageEnd()
4425 
    oprot.trans.flush()
4426 
 
4427 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4428 
    args = getValidItemsByCatalogId_args()
4429 
    args.read(iprot)
4430 
    iprot.readMessageEnd()
4431 
    result = getValidItemsByCatalogId_result()
4432 
    try:
4433 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4434 
    except CatalogServiceException, cex:
4435 
      result.cex = cex
4436 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4437 
    result.write(oprot)
4438 
    oprot.writeMessageEnd()
4439 
    oprot.trans.flush()
4440 
 
4441 
  def process_getAllItems(self, seqid, iprot, oprot):
4442 
    args = getAllItems_args()
4443 
    args.read(iprot)
4444 
    iprot.readMessageEnd()
4445 
    result = getAllItems_result()
4446 
    try:
4447 
      result.success = self._handler.getAllItems(args.isActive)
4448 
    except CatalogServiceException, cex:
4449 
      result.cex = cex
4450 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
4454 
 
4455 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4456 
    args = getAllItemsByStatus_args()
4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
4459 
    result = getAllItemsByStatus_result()
4460 
    try:
4461 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4462 
    except CatalogServiceException, cex:
4463 
      result.cex = cex
4464 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4465 
    result.write(oprot)
4466 
    oprot.writeMessageEnd()
4467 
    oprot.trans.flush()
4468 
 
4469 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4470 
    args = markItemAsContentComplete_args()
4471 
    args.read(iprot)
4472 
    iprot.readMessageEnd()
4473 
    result = markItemAsContentComplete_result()
4474 
    try:
4475 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4476 
    except CatalogServiceException, cex:
4477 
      result.cex = cex
4478 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4479 
    result.write(oprot)
4480 
    oprot.writeMessageEnd()
4481 
    oprot.trans.flush()
4482 
 
4483 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4484 
    args = getAllItemsInRange_args()
4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
4487 
    result = getAllItemsInRange_result()
4488 
    try:
4489 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4490 
    except CatalogServiceException, cex:
4491 
      result.cex = cex
4492 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4493 
    result.write(oprot)
4494 
    oprot.writeMessageEnd()
4495 
    oprot.trans.flush()
4496 
 
4497 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4498 
    args = getAllItemsByStatusInRange_args()
4499 
    args.read(iprot)
4500 
    iprot.readMessageEnd()
4501 
    result = getAllItemsByStatusInRange_result()
4502 
    try:
4503 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4504 
    except CatalogServiceException, cex:
4505 
      result.cex = cex
4506 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4507 
    result.write(oprot)
4508 
    oprot.writeMessageEnd()
4509 
    oprot.trans.flush()
4510 
 
4511 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4512 
    args = getItemCountByStatus_args()
4513 
    args.read(iprot)
4514 
    iprot.readMessageEnd()
4515 
    result = getItemCountByStatus_result()
4516 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4517 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4518 
    result.write(oprot)
4519 
    oprot.writeMessageEnd()
4520 
    oprot.trans.flush()
4521 
 
4522 
  def process_getBestSellers(self, seqid, iprot, oprot):
4523 
    args = getBestSellers_args()
4524 
    args.read(iprot)
4525 
    iprot.readMessageEnd()
4526 
    result = getBestSellers_result()
4527 
    try:
4528 
      result.success = self._handler.getBestSellers()
4529 
    except CatalogServiceException, isex:
4530 
      result.isex = isex
4531 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4532 
    result.write(oprot)
4533 
    oprot.writeMessageEnd()
4534 
    oprot.trans.flush()
4535 
 
4536 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4537 
    args = getBestSellersCatalogIds_args()
4538 
    args.read(iprot)
4539 
    iprot.readMessageEnd()
4540 
    result = getBestSellersCatalogIds_result()
4541 
    try:
4542 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4543 
    except CatalogServiceException, cex:
4544 
      result.cex = cex
4545 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4546 
    result.write(oprot)
4547 
    oprot.writeMessageEnd()
4548 
    oprot.trans.flush()
4549 
 
4550 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4551 
    args = getBestSellersCount_args()
4552 
    args.read(iprot)
4553 
    iprot.readMessageEnd()
4554 
    result = getBestSellersCount_result()
4555 
    try:
4556 
      result.success = self._handler.getBestSellersCount()
4557 
    except CatalogServiceException, cex:
4558 
      result.cex = cex
4559 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4560 
    result.write(oprot)
4561 
    oprot.writeMessageEnd()
4562 
    oprot.trans.flush()
4563 
 
4564 
  def process_getBestDeals(self, seqid, iprot, oprot):
4565 
    args = getBestDeals_args()
4566 
    args.read(iprot)
4567 
    iprot.readMessageEnd()
4568 
    result = getBestDeals_result()
4569 
    try:
4570 
      result.success = self._handler.getBestDeals()
4571 
    except CatalogServiceException, isex:
4572 
      result.isex = isex
4573 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4574 
    result.write(oprot)
4575 
    oprot.writeMessageEnd()
4576 
    oprot.trans.flush()
4577 
 
4578 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4579 
    args = getBestDealsCatalogIds_args()
4580 
    args.read(iprot)
4581 
    iprot.readMessageEnd()
4582 
    result = getBestDealsCatalogIds_result()
4583 
    try:
4584 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4585 
    except CatalogServiceException, cex:
4586 
      result.cex = cex
4587 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4588 
    result.write(oprot)
4589 
    oprot.writeMessageEnd()
4590 
    oprot.trans.flush()
4591 
 
4592 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4593 
    args = getBestDealsCount_args()
4594 
    args.read(iprot)
4595 
    iprot.readMessageEnd()
4596 
    result = getBestDealsCount_result()
4597 
    try:
4598 
      result.success = self._handler.getBestDealsCount()
4599 
    except CatalogServiceException, cex:
4600 
      result.cex = cex
4601 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4602 
    result.write(oprot)
4603 
    oprot.writeMessageEnd()
4604 
    oprot.trans.flush()
4605 
 
4606 
  def process_getComingSoon(self, seqid, iprot, oprot):
4607 
    args = getComingSoon_args()
4608 
    args.read(iprot)
4609 
    iprot.readMessageEnd()
4610 
    result = getComingSoon_result()
4611 
    try:
4612 
      result.success = self._handler.getComingSoon()
4613 
    except CatalogServiceException, isex:
4614 
      result.isex = isex
4615 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4616 
    result.write(oprot)
4617 
    oprot.writeMessageEnd()
4618 
    oprot.trans.flush()
4619 
 
4620 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4621 
    args = getComingSoonCatalogIds_args()
4622 
    args.read(iprot)
4623 
    iprot.readMessageEnd()
4624 
    result = getComingSoonCatalogIds_result()
4625 
    try:
4626 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4627 
    except CatalogServiceException, cex:
4628 
      result.cex = cex
4629 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4630 
    result.write(oprot)
4631 
    oprot.writeMessageEnd()
4632 
    oprot.trans.flush()
4633 
 
4634 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4635 
    args = getComingSoonCount_args()
4636 
    args.read(iprot)
4637 
    iprot.readMessageEnd()
4638 
    result = getComingSoonCount_result()
4639 
    try:
4640 
      result.success = self._handler.getComingSoonCount()
4641 
    except CatalogServiceException, cex:
4642 
      result.cex = cex
4643 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4644 
    result.write(oprot)
4645 
    oprot.writeMessageEnd()
4646 
    oprot.trans.flush()
4647 
 
4648 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4649 
    args = getLatestArrivals_args()
4650 
    args.read(iprot)
4651 
    iprot.readMessageEnd()
4652 
    result = getLatestArrivals_result()
4653 
    try:
4654 
      result.success = self._handler.getLatestArrivals()
4655 
    except CatalogServiceException, isex:
4656 
      result.isex = isex
4657 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4658 
    result.write(oprot)
4659 
    oprot.writeMessageEnd()
4660 
    oprot.trans.flush()
4661 
 
4662 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4663 
    args = getLatestArrivalsCatalogIds_args()
4664 
    args.read(iprot)
4665 
    iprot.readMessageEnd()
4666 
    result = getLatestArrivalsCatalogIds_result()
4667 
    try:
4668 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4669 
    except CatalogServiceException, cex:
4670 
      result.cex = cex
4671 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
4676 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4677 
    args = getLatestArrivalsCount_args()
4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
4680 
    result = getLatestArrivalsCount_result()
4681 
    try:
4682 
      result.success = self._handler.getLatestArrivalsCount()
4683 
    except CatalogServiceException, cex:
4684 
      result.cex = cex
4685 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4686 
    result.write(oprot)
4687 
    oprot.writeMessageEnd()
4688 
    oprot.trans.flush()
4689 
 
4690 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4691 
    args = generateNewEntityID_args()
4692 
    args.read(iprot)
4693 
    iprot.readMessageEnd()
4694 
    result = generateNewEntityID_result()
4695 
    result.success = self._handler.generateNewEntityID()
4696 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4697 
    result.write(oprot)
4698 
    oprot.writeMessageEnd()
4699 
    oprot.trans.flush()
4700 
 
4701 
  def process_addCategory(self, seqid, iprot, oprot):
4702 
    args = addCategory_args()
4703 
    args.read(iprot)
4704 
    iprot.readMessageEnd()
4705 
    result = addCategory_result()
4706 
    result.success = self._handler.addCategory(args.category)
4707 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4708 
    result.write(oprot)
4709 
    oprot.writeMessageEnd()
4710 
    oprot.trans.flush()
4711 
 
4712 
  def process_getCategory(self, seqid, iprot, oprot):
4713 
    args = getCategory_args()
4714 
    args.read(iprot)
4715 
    iprot.readMessageEnd()
4716 
    result = getCategory_result()
4717 
    result.success = self._handler.getCategory(args.id)
4718 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4719 
    result.write(oprot)
4720 
    oprot.writeMessageEnd()
4721 
    oprot.trans.flush()
4722 
 
4723 
  def process_getAllCategories(self, seqid, iprot, oprot):
4724 
    args = getAllCategories_args()
4725 
    args.read(iprot)
4726 
    iprot.readMessageEnd()
4727 
    result = getAllCategories_result()
4728 
    result.success = self._handler.getAllCategories()
4729 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
4734 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4735 
    args = getAllSimilarItems_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = getAllSimilarItems_result()
4739 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4740 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4741 
    result.write(oprot)
4742 
    oprot.writeMessageEnd()
4743 
    oprot.trans.flush()
4744 
 
4745 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4746 
    args = addSimilarItem_args()
4747 
    args.read(iprot)
4748 
    iprot.readMessageEnd()
4749 
    result = addSimilarItem_result()
4750 
    try:
4751 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4752 
    except CatalogServiceException, cex:
4753 
      result.cex = cex
4754 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
6512 kshitij.so 4759 
  def process_addTag(self, seqid, iprot, oprot):
4760 
    args = addTag_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = addTag_result()
4764 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4765 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
4770 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4771 
    args = deleteEntityTag_args()
4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
4774 
    result = deleteEntityTag_result()
4775 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4776 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4777 
    result.write(oprot)
4778 
    oprot.writeMessageEnd()
4779 
    oprot.trans.flush()
4780 
 
4781 
  def process_deleteTag(self, seqid, iprot, oprot):
4782 
    args = deleteTag_args()
4783 
    args.read(iprot)
4784 
    iprot.readMessageEnd()
4785 
    result = deleteTag_result()
4786 
    result.success = self._handler.deleteTag(args.displayName)
4787 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
4792 
  def process_getAllTags(self, seqid, iprot, oprot):
4793 
    args = getAllTags_args()
4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
4796 
    result = getAllTags_result()
4797 
    result.success = self._handler.getAllTags()
4798 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
4803 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4804 
    args = getAllEntitiesByTagName_args()
4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
4807 
    result = getAllEntitiesByTagName_result()
4808 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4809 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4810 
    result.write(oprot)
4811 
    oprot.writeMessageEnd()
4812 
    oprot.trans.flush()
4813 
 
6845 amit.gupta 4814 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4815 
    args = getAllEntityTags_args()
4816 
    args.read(iprot)
4817 
    iprot.readMessageEnd()
4818 
    result = getAllEntityTags_result()
4819 
    result.success = self._handler.getAllEntityTags()
4820 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4821 
    result.write(oprot)
4822 
    oprot.writeMessageEnd()
4823 
    oprot.trans.flush()
4824 
 
6850 kshitij.so 4825 
  def process_addBanner(self, seqid, iprot, oprot):
4826 
    args = addBanner_args()
4827 
    args.read(iprot)
4828 
    iprot.readMessageEnd()
4829 
    result = addBanner_result()
4830 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4831 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4832 
    result.write(oprot)
4833 
    oprot.writeMessageEnd()
4834 
    oprot.trans.flush()
4835 
 
4836 
  def process_getAllBanners(self, seqid, iprot, oprot):
4837 
    args = getAllBanners_args()
4838 
    args.read(iprot)
4839 
    iprot.readMessageEnd()
4840 
    result = getAllBanners_result()
4841 
    result.success = self._handler.getAllBanners()
4842 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4843 
    result.write(oprot)
4844 
    oprot.writeMessageEnd()
4845 
    oprot.trans.flush()
4846 
 
4847 
  def process_deleteBanner(self, seqid, iprot, oprot):
4848 
    args = deleteBanner_args()
4849 
    args.read(iprot)
4850 
    iprot.readMessageEnd()
4851 
    result = deleteBanner_result()
4852 
    result.success = self._handler.deleteBanner(args.bannerName)
4853 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4854 
    result.write(oprot)
4855 
    oprot.writeMessageEnd()
4856 
    oprot.trans.flush()
4857 
 
4858 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4859 
    args = getBannerDetails_args()
4860 
    args.read(iprot)
4861 
    iprot.readMessageEnd()
4862 
    result = getBannerDetails_result()
4863 
    result.success = self._handler.getBannerDetails(args.bannerName)
4864 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4865 
    result.write(oprot)
4866 
    oprot.writeMessageEnd()
4867 
    oprot.trans.flush()
4868 
 
4869 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4870 
    args = getActiveBanners_args()
4871 
    args.read(iprot)
4872 
    iprot.readMessageEnd()
4873 
    result = getActiveBanners_result()
4874 
    result.success = self._handler.getActiveBanners()
4875 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4876 
    result.write(oprot)
4877 
    oprot.writeMessageEnd()
4878 
    oprot.trans.flush()
4879 
 
6849 kshitij.so 4880 
  def process_addBannerMap(self, seqid, iprot, oprot):
4881 
    args = addBannerMap_args()
4882 
    args.read(iprot)
4883 
    iprot.readMessageEnd()
4884 
    result = addBannerMap_result()
4885 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4886 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4887 
    result.write(oprot)
4888 
    oprot.writeMessageEnd()
4889 
    oprot.trans.flush()
4890 
 
4891 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4892 
    args = deleteBannerMap_args()
4893 
    args.read(iprot)
4894 
    iprot.readMessageEnd()
4895 
    result = deleteBannerMap_result()
4896 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4897 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4898 
    result.write(oprot)
4899 
    oprot.writeMessageEnd()
4900 
    oprot.trans.flush()
4901 
 
4902 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4903 
    args = getBannerMapDetails_args()
4904 
    args.read(iprot)
4905 
    iprot.readMessageEnd()
4906 
    result = getBannerMapDetails_result()
4907 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4908 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4909 
    result.write(oprot)
4910 
    oprot.writeMessageEnd()
4911 
    oprot.trans.flush()
4912 
 
5944 mandeep.dh 4913 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4914 
    args = deleteSimilarItem_args()
4915 
    args.read(iprot)
4916 
    iprot.readMessageEnd()
4917 
    result = deleteSimilarItem_result()
4918 
    try:
4919 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4920 
    except CatalogServiceException, cex:
4921 
      result.cex = cex
4922 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4923 
    result.write(oprot)
4924 
    oprot.writeMessageEnd()
4925 
    oprot.trans.flush()
4926 
 
4927 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4928 
    args = checkSimilarItem_args()
4929 
    args.read(iprot)
4930 
    iprot.readMessageEnd()
4931 
    result = checkSimilarItem_result()
4932 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4933 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
4937 
 
4938 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4939 
    args = validateRiskyStatus_args()
4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
4942 
    result = validateRiskyStatus_result()
4943 
    self._handler.validateRiskyStatus(args.itemId)
4944 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4948 
 
4949 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4950 
    args = changeItemRiskyFlag_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = changeItemRiskyFlag_result()
4954 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4955 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4956 
    result.write(oprot)
4957 
    oprot.writeMessageEnd()
4958 
    oprot.trans.flush()
4959 
 
4960 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4961 
    args = getItemsByRiskyFlag_args()
4962 
    args.read(iprot)
4963 
    iprot.readMessageEnd()
4964 
    result = getItemsByRiskyFlag_result()
4965 
    result.success = self._handler.getItemsByRiskyFlag()
4966 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4967 
    result.write(oprot)
4968 
    oprot.writeMessageEnd()
4969 
    oprot.trans.flush()
4970 
 
4971 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4972 
    args = getItemsForMasterSheet_args()
4973 
    args.read(iprot)
4974 
    iprot.readMessageEnd()
4975 
    result = getItemsForMasterSheet_result()
4976 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4977 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4978 
    result.write(oprot)
4979 
    oprot.writeMessageEnd()
4980 
    oprot.trans.flush()
4981 
 
4982 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4983 
    args = getSimilarItemsCatalogIds_args()
4984 
    args.read(iprot)
4985 
    iprot.readMessageEnd()
4986 
    result = getSimilarItemsCatalogIds_result()
4987 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4988 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
4993 
  def process_addProductNotification(self, seqid, iprot, oprot):
4994 
    args = addProductNotification_args()
4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
4997 
    result = addProductNotification_result()
4998 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4999 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5000 
    result.write(oprot)
5001 
    oprot.writeMessageEnd()
5002 
    oprot.trans.flush()
5003 
 
5004 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5005 
    args = sendProductNotifications_args()
5006 
    args.read(iprot)
5007 
    iprot.readMessageEnd()
5008 
    result = sendProductNotifications_result()
5009 
    result.success = self._handler.sendProductNotifications()
5010 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5011 
    result.write(oprot)
5012 
    oprot.writeMessageEnd()
5013 
    oprot.trans.flush()
5014 
 
5015 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5016 
    args = getAllBrandsByCategory_args()
5017 
    args.read(iprot)
5018 
    iprot.readMessageEnd()
5019 
    result = getAllBrandsByCategory_result()
5020 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5021 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5022 
    result.write(oprot)
5023 
    oprot.writeMessageEnd()
5024 
    oprot.trans.flush()
5025 
 
5026 
  def process_getAllBrands(self, seqid, iprot, oprot):
5027 
    args = getAllBrands_args()
5028 
    args.read(iprot)
5029 
    iprot.readMessageEnd()
5030 
    result = getAllBrands_result()
5031 
    result.success = self._handler.getAllBrands()
5032 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5033 
    result.write(oprot)
5034 
    oprot.writeMessageEnd()
5035 
    oprot.trans.flush()
5036 
 
5037 
  def process_getAllSources(self, seqid, iprot, oprot):
5038 
    args = getAllSources_args()
5039 
    args.read(iprot)
5040 
    iprot.readMessageEnd()
5041 
    result = getAllSources_result()
5042 
    result.success = self._handler.getAllSources()
5043 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5044 
    result.write(oprot)
5045 
    oprot.writeMessageEnd()
5046 
    oprot.trans.flush()
5047 
 
5048 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5049 
    args = getItemPricingBySource_args()
5050 
    args.read(iprot)
5051 
    iprot.readMessageEnd()
5052 
    result = getItemPricingBySource_result()
5053 
    try:
5054 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5055 
    except CatalogServiceException, cex:
5056 
      result.cex = cex
5057 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5058 
    result.write(oprot)
5059 
    oprot.writeMessageEnd()
5060 
    oprot.trans.flush()
5061 
 
5062 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5063 
    args = addSourceItemPricing_args()
5064 
    args.read(iprot)
5065 
    iprot.readMessageEnd()
5066 
    result = addSourceItemPricing_result()
5067 
    try:
5068 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5069 
    except CatalogServiceException, cex:
5070 
      result.cex = cex
5071 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5072 
    result.write(oprot)
5073 
    oprot.writeMessageEnd()
5074 
    oprot.trans.flush()
5075 
 
5076 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5077 
    args = getAllSourcePricing_args()
5078 
    args.read(iprot)
5079 
    iprot.readMessageEnd()
5080 
    result = getAllSourcePricing_result()
5081 
    try:
5082 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5083 
    except CatalogServiceException, cex:
5084 
      result.cex = cex
5085 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5086 
    result.write(oprot)
5087 
    oprot.writeMessageEnd()
5088 
    oprot.trans.flush()
5089 
 
5090 
  def process_getItemForSource(self, seqid, iprot, oprot):
5091 
    args = getItemForSource_args()
5092 
    args.read(iprot)
5093 
    iprot.readMessageEnd()
5094 
    result = getItemForSource_result()
5095 
    try:
5096 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5097 
    except CatalogServiceException, cex:
5098 
      result.cex = cex
5099 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5100 
    result.write(oprot)
5101 
    oprot.writeMessageEnd()
5102 
    oprot.trans.flush()
5103 
 
5104 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5105 
    args = searchItemsInRange_args()
5106 
    args.read(iprot)
5107 
    iprot.readMessageEnd()
5108 
    result = searchItemsInRange_result()
5109 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5110 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5111 
    result.write(oprot)
5112 
    oprot.writeMessageEnd()
5113 
    oprot.trans.flush()
5114 
 
5115 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5116 
    args = getSearchResultCount_args()
5117 
    args.read(iprot)
5118 
    iprot.readMessageEnd()
5119 
    result = getSearchResultCount_result()
5120 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5121 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5122 
    result.write(oprot)
5123 
    oprot.writeMessageEnd()
5124 
    oprot.trans.flush()
5125 
 
5126 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5127 
    args = getProductNotifications_args()
5128 
    args.read(iprot)
5129 
    iprot.readMessageEnd()
5130 
    result = getProductNotifications_result()
5131 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5132 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5133 
    result.write(oprot)
5134 
    oprot.writeMessageEnd()
5135 
    oprot.trans.flush()
5136 
 
5137 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5138 
    args = getProductNotificationRequestCount_args()
5139 
    args.read(iprot)
5140 
    iprot.readMessageEnd()
5141 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5142 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5143 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5144 
    result.write(oprot)
5145 
    oprot.writeMessageEnd()
5146 
    oprot.trans.flush()
5147 
 
5148 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5149 
    args = addAuthorizationLog_args()
5150 
    args.read(iprot)
5151 
    iprot.readMessageEnd()
5152 
    result = addAuthorizationLog_result()
5153 
    try:
5154 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5155 
    except CatalogServiceException, cex:
5156 
      result.cex = cex
5157 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5158 
    result.write(oprot)
5159 
    oprot.writeMessageEnd()
5160 
    oprot.trans.flush()
5161 
 
5162 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5163 
    args = addupdateVoucherForItem_args()
5164 
    args.read(iprot)
5165 
    iprot.readMessageEnd()
5166 
    result = addupdateVoucherForItem_result()
5167 
    try:
5168 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5169 
    except CatalogServiceException, cex:
5170 
      result.cex = cex
5171 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5172 
    result.write(oprot)
5173 
    oprot.writeMessageEnd()
5174 
    oprot.trans.flush()
5175 
 
5176 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5177 
    args = deleteVoucherForItem_args()
5178 
    args.read(iprot)
5179 
    iprot.readMessageEnd()
5180 
    result = deleteVoucherForItem_result()
5181 
    try:
5182 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5183 
    except CatalogServiceException, cex:
5184 
      result.cex = cex
5185 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5186 
    result.write(oprot)
5187 
    oprot.writeMessageEnd()
5188 
    oprot.trans.flush()
5189 
 
5190 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5191 
    args = getVoucherAmount_args()
5192 
    args.read(iprot)
5193 
    iprot.readMessageEnd()
5194 
    result = getVoucherAmount_result()
5195 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5196 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5197 
    result.write(oprot)
5198 
    oprot.writeMessageEnd()
5199 
    oprot.trans.flush()
5200 
 
5201 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5202 
    args = getAllItemVouchers_args()
5203 
    args.read(iprot)
5204 
    iprot.readMessageEnd()
5205 
    result = getAllItemVouchers_result()
5206 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5207 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5208 
    result.write(oprot)
5209 
    oprot.writeMessageEnd()
5210 
    oprot.trans.flush()
5211 
 
5212 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5213 
    args = isValidCatalogItemId_args()
5214 
    args.read(iprot)
5215 
    iprot.readMessageEnd()
5216 
    result = isValidCatalogItemId_result()
5217 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5218 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5219 
    result.write(oprot)
5220 
    oprot.writeMessageEnd()
5221 
    oprot.trans.flush()
5222 
 
6039 amit.gupta 5223 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5224 
    args = getVatPercentageForItem_args()
5225 
    args.read(iprot)
5226 
    iprot.readMessageEnd()
5227 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5228 
    try:
5229 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5230 
    except CatalogServiceException, cex:
5231 
      result.cex = cex
6039 amit.gupta 5232 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5233 
    result.write(oprot)
5234 
    oprot.writeMessageEnd()
5235 
    oprot.trans.flush()
5944 mandeep.dh 5236 
 
6039 amit.gupta 5237 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5238 
    args = getVatAmountForItem_args()
5239 
    args.read(iprot)
5240 
    iprot.readMessageEnd()
5241 
    result = getVatAmountForItem_result()
5242 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5243 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5244 
    result.write(oprot)
5245 
    oprot.writeMessageEnd()
5246 
    oprot.trans.flush()
5247 
 
6531 vikram.rag 5248 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5249 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5250 
    args.read(iprot)
5251 
    iprot.readMessageEnd()
5252 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5253 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5254 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5255 
    result.write(oprot)
5256 
    oprot.writeMessageEnd()
5257 
    oprot.trans.flush()
6039 amit.gupta 5258 
 
6821 amar.kumar 5259 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5260 
    args = getAllAliveItems_args()
5261 
    args.read(iprot)
5262 
    iprot.readMessageEnd()
5263 
    result = getAllAliveItems_result()
5264 
    result.success = self._handler.getAllAliveItems()
5265 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
6805 anupam.sin 5270 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5271 
    args = getInsuranceAmount_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = getInsuranceAmount_result()
6921 anupam.sin 5275 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5276 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
6531 vikram.rag 5280 
 
6805 anupam.sin 5281 
  def process_getInsurer(self, seqid, iprot, oprot):
5282 
    args = getInsurer_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = getInsurer_result()
5286 
    result.success = self._handler.getInsurer(args.insurerId)
5287 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
5291 
 
6838 vikram.rag 5292 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5293 
    args = getAllInsurers_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = getAllInsurers_result()
5297 
    result.success = self._handler.getAllInsurers()
5298 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
6805 anupam.sin 5302 
 
6962 rajveer 5303 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5304 
    args = updateInsuranceDeclaredAmount_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = updateInsuranceDeclaredAmount_result()
5308 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5309 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
6838 vikram.rag 5313 
 
7190 amar.kumar 5314 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5315 
    args = getFreebieForItem_args()
5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
5318 
    result = getFreebieForItem_result()
5319 
    result.success = self._handler.getFreebieForItem(args.itemId)
5320 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
6962 rajveer 5324 
 
7190 amar.kumar 5325 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5326 
    args = addOrUpdateFreebieForItem_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = addOrUpdateFreebieForItem_result()
5330 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5331 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5332 
    result.write(oprot)
5333 
    oprot.writeMessageEnd()
5334 
    oprot.trans.flush()
5335 
 
7272 amit.gupta 5336 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5337 
    args = addOrUpdateBrandInfo_args()
5338 
    args.read(iprot)
5339 
    iprot.readMessageEnd()
5340 
    result = addOrUpdateBrandInfo_result()
5341 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5342 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5343 
    result.write(oprot)
5344 
    oprot.writeMessageEnd()
5345 
    oprot.trans.flush()
5346 
 
5347 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5348 
    args = getBrandInfo_args()
5349 
    args.read(iprot)
5350 
    iprot.readMessageEnd()
5351 
    result = getBrandInfo_result()
5352 
    result.success = self._handler.getBrandInfo()
5353 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5354 
    result.write(oprot)
5355 
    oprot.writeMessageEnd()
5356 
    oprot.trans.flush()
5357 
 
7256 rajveer 5358 
  def process_getStorePricing(self, seqid, iprot, oprot):
5359 
    args = getStorePricing_args()
5360 
    args.read(iprot)
5361 
    iprot.readMessageEnd()
5362 
    result = getStorePricing_result()
5363 
    result.success = self._handler.getStorePricing(args.itemId)
5364 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5365 
    result.write(oprot)
5366 
    oprot.writeMessageEnd()
5367 
    oprot.trans.flush()
7190 amar.kumar 5368 
 
7306 rajveer 5369 
  def process_getStorePricings(self, seqid, iprot, oprot):
5370 
    args = getStorePricings_args()
5371 
    args.read(iprot)
5372 
    iprot.readMessageEnd()
5373 
    result = getStorePricings_result()
5374 
    result.success = self._handler.getStorePricings(args.itemIds)
5375 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5376 
    result.write(oprot)
5377 
    oprot.writeMessageEnd()
5378 
    oprot.trans.flush()
5379 
 
7265 rajveer 5380 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5381 
    args = updateStorePricing_args()
5382 
    args.read(iprot)
5383 
    iprot.readMessageEnd()
5384 
    result = updateStorePricing_result()
7382 rajveer 5385 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5386 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5387 
    result.write(oprot)
5388 
    oprot.writeMessageEnd()
5389 
    oprot.trans.flush()
7256 rajveer 5390 
 
7281 kshitij.so 5391 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5392 
    args = getAllAmazonListedItems_args()
5393 
    args.read(iprot)
5394 
    iprot.readMessageEnd()
5395 
    result = getAllAmazonListedItems_result()
5396 
    result.success = self._handler.getAllAmazonListedItems()
5397 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5398 
    result.write(oprot)
5399 
    oprot.writeMessageEnd()
5400 
    oprot.trans.flush()
7265 rajveer 5401 
 
7281 kshitij.so 5402 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5403 
    args = getAmazonItemDetails_args()
5404 
    args.read(iprot)
5405 
    iprot.readMessageEnd()
5406 
    result = getAmazonItemDetails_result()
5407 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5408 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5409 
    result.write(oprot)
5410 
    oprot.writeMessageEnd()
5411 
    oprot.trans.flush()
5412 
 
5413 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5414 
    args = updateAmazonItemDetails_args()
5415 
    args.read(iprot)
5416 
    iprot.readMessageEnd()
5417 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 5418 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 5419 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5420 
    result.write(oprot)
5421 
    oprot.writeMessageEnd()
5422 
    oprot.trans.flush()
5423 
 
5424 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5425 
    args = addAmazonItem_args()
5426 
    args.read(iprot)
5427 
    iprot.readMessageEnd()
5428 
    result = addAmazonItem_result()
5429 
    self._handler.addAmazonItem(args.amazonlisted)
5430 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5431 
    result.write(oprot)
5432 
    oprot.writeMessageEnd()
5433 
    oprot.trans.flush()
5434 
 
7291 vikram.rag 5435 
  def process_getAsinItems(self, seqid, iprot, oprot):
5436 
    args = getAsinItems_args()
5437 
    args.read(iprot)
5438 
    iprot.readMessageEnd()
5439 
    result = getAsinItems_result()
5440 
    result.success = self._handler.getAsinItems()
5441 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5442 
    result.write(oprot)
5443 
    oprot.writeMessageEnd()
5444 
    oprot.trans.flush()
7281 kshitij.so 5445 
 
7291 vikram.rag 5446 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5447 
    args = getAllFbaListedItems_args()
5448 
    args.read(iprot)
5449 
    iprot.readMessageEnd()
5450 
    result = getAllFbaListedItems_result()
5451 
    result.success = self._handler.getAllFbaListedItems()
5452 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5453 
    result.write(oprot)
5454 
    oprot.writeMessageEnd()
5455 
    oprot.trans.flush()
5456 
 
5457 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5458 
    args = getAllNonFbaListedItems_args()
5459 
    args.read(iprot)
5460 
    iprot.readMessageEnd()
5461 
    result = getAllNonFbaListedItems_result()
5462 
    result.success = self._handler.getAllNonFbaListedItems()
5463 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5464 
    result.write(oprot)
5465 
    oprot.writeMessageEnd()
5466 
    oprot.trans.flush()
5467 
 
7460 kshitij.so 5468 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5469 
    args = updateItemInventory_args()
5470 
    args.read(iprot)
5471 
    iprot.readMessageEnd()
5472 
    result = updateItemInventory_result()
5473 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5474 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5475 
    result.write(oprot)
5476 
    oprot.writeMessageEnd()
5477 
    oprot.trans.flush()
7291 vikram.rag 5478 
 
7770 kshitij.so 5479 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5480 
    args = updateTimestampForAmazonFeeds_args()
5481 
    args.read(iprot)
5482 
    iprot.readMessageEnd()
5483 
    result = updateTimestampForAmazonFeeds_result()
5484 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5485 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5486 
    result.write(oprot)
5487 
    oprot.writeMessageEnd()
5488 
    oprot.trans.flush()
7460 kshitij.so 5489 
 
7897 amar.kumar 5490 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5491 
    args = getAllParentCategories_args()
5492 
    args.read(iprot)
5493 
    iprot.readMessageEnd()
5494 
    result = getAllParentCategories_result()
5495 
    result.success = self._handler.getAllParentCategories()
5496 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5497 
    result.write(oprot)
5498 
    oprot.writeMessageEnd()
5499 
    oprot.trans.flush()
7770 kshitij.so 5500 
 
7977 kshitij.so 5501 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5502 
    args = addPageViewEvent_args()
5503 
    args.read(iprot)
5504 
    iprot.readMessageEnd()
5505 
    result = addPageViewEvent_result()
5506 
    self._handler.addPageViewEvent(args.pageViewEvents)
5507 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5508 
    result.write(oprot)
5509 
    oprot.writeMessageEnd()
5510 
    oprot.trans.flush()
7897 amar.kumar 5511 
 
7977 kshitij.so 5512 
  def process_addCartEvent(self, seqid, iprot, oprot):
5513 
    args = addCartEvent_args()
5514 
    args.read(iprot)
5515 
    iprot.readMessageEnd()
5516 
    result = addCartEvent_result()
5517 
    self._handler.addCartEvent(args.cartEvents)
5518 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5519 
    result.write(oprot)
5520 
    oprot.writeMessageEnd()
5521 
    oprot.trans.flush()
5522 
 
8182 amar.kumar 5523 
  def process_addEbayItem(self, seqid, iprot, oprot):
5524 
    args = addEbayItem_args()
5525 
    args.read(iprot)
5526 
    iprot.readMessageEnd()
5527 
    result = addEbayItem_result()
5528 
    self._handler.addEbayItem(args.ebayItem)
5529 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
5530 
    result.write(oprot)
5531 
    oprot.writeMessageEnd()
5532 
    oprot.trans.flush()
5533 
 
5534 
  def process_getEbayItem(self, seqid, iprot, oprot):
5535 
    args = getEbayItem_args()
5536 
    args.read(iprot)
5537 
    iprot.readMessageEnd()
5538 
    result = getEbayItem_result()
5539 
    result.success = self._handler.getEbayItem(args.listingId)
5540 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
5541 
    result.write(oprot)
5542 
    oprot.writeMessageEnd()
5543 
    oprot.trans.flush()
5544 
 
5545 
  def process_updateEbayItem(self, seqid, iprot, oprot):
5546 
    args = updateEbayItem_args()
5547 
    args.read(iprot)
5548 
    iprot.readMessageEnd()
5549 
    result = updateEbayItem_result()
5550 
    self._handler.updateEbayItem(args.ebayItem)
5551 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
5552 
    result.write(oprot)
5553 
    oprot.writeMessageEnd()
5554 
    oprot.trans.flush()
5555 
 
8139 kshitij.so 5556 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
5557 
    args = getAmazonListedItems_args()
5558 
    args.read(iprot)
5559 
    iprot.readMessageEnd()
5560 
    result = getAmazonListedItems_result()
5561 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
5562 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
5563 
    result.write(oprot)
5564 
    oprot.writeMessageEnd()
5565 
    oprot.trans.flush()
7977 kshitij.so 5566 
 
8168 kshitij.so 5567 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
5568 
    args = updateAmazonAttributesInBulk_args()
5569 
    args.read(iprot)
5570 
    iprot.readMessageEnd()
5571 
    result = updateAmazonAttributesInBulk_result()
5572 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
5573 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
5574 
    result.write(oprot)
5575 
    oprot.writeMessageEnd()
5576 
    oprot.trans.flush()
8139 kshitij.so 5577 
 
8168 kshitij.so 5578 
 
5944 mandeep.dh 5579 
# HELPER FUNCTIONS AND STRUCTURES
5580 
 
5581 
class addItem_args:
5582 
  """
5583 
  Attributes:
5584 
   - item
5585 
  """
5586 
 
5587 
  thrift_spec = (
5588 
    None, # 0
5589 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5590 
  )
5591 
 
5592 
  def __init__(self, item=None,):
5593 
    self.item = item
5594 
 
5595 
  def read(self, iprot):
5596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5598 
      return
5599 
    iprot.readStructBegin()
5600 
    while True:
5601 
      (fname, ftype, fid) = iprot.readFieldBegin()
5602 
      if ftype == TType.STOP:
5603 
        break
5604 
      if fid == 1:
5605 
        if ftype == TType.STRUCT:
5606 
          self.item = Item()
5607 
          self.item.read(iprot)
5608 
        else:
5609 
          iprot.skip(ftype)
5610 
      else:
5611 
        iprot.skip(ftype)
5612 
      iprot.readFieldEnd()
5613 
    iprot.readStructEnd()
5614 
 
5615 
  def write(self, oprot):
5616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5618 
      return
5619 
    oprot.writeStructBegin('addItem_args')
5620 
    if self.item is not None:
5621 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5622 
      self.item.write(oprot)
5623 
      oprot.writeFieldEnd()
5624 
    oprot.writeFieldStop()
5625 
    oprot.writeStructEnd()
5626 
 
5627 
  def validate(self):
5628 
    return
5629 
 
5630 
 
5631 
  def __repr__(self):
5632 
    L = ['%s=%r' % (key, value)
5633 
      for key, value in self.__dict__.iteritems()]
5634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5635 
 
5636 
  def __eq__(self, other):
5637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5638 
 
5639 
  def __ne__(self, other):
5640 
    return not (self == other)
5641 
 
5642 
class addItem_result:
5643 
  """
5644 
  Attributes:
5645 
   - success
5646 
   - cex
5647 
  """
5648 
 
5649 
  thrift_spec = (
5650 
    (0, TType.I64, 'success', None, None, ), # 0
5651 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5652 
  )
5653 
 
5654 
  def __init__(self, success=None, cex=None,):
5655 
    self.success = success
5656 
    self.cex = cex
5657 
 
5658 
  def read(self, iprot):
5659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5661 
      return
5662 
    iprot.readStructBegin()
5663 
    while True:
5664 
      (fname, ftype, fid) = iprot.readFieldBegin()
5665 
      if ftype == TType.STOP:
5666 
        break
5667 
      if fid == 0:
5668 
        if ftype == TType.I64:
5669 
          self.success = iprot.readI64();
5670 
        else:
5671 
          iprot.skip(ftype)
5672 
      elif fid == 1:
5673 
        if ftype == TType.STRUCT:
5674 
          self.cex = CatalogServiceException()
5675 
          self.cex.read(iprot)
5676 
        else:
5677 
          iprot.skip(ftype)
5678 
      else:
5679 
        iprot.skip(ftype)
5680 
      iprot.readFieldEnd()
5681 
    iprot.readStructEnd()
5682 
 
5683 
  def write(self, oprot):
5684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5686 
      return
5687 
    oprot.writeStructBegin('addItem_result')
5688 
    if self.success is not None:
5689 
      oprot.writeFieldBegin('success', TType.I64, 0)
5690 
      oprot.writeI64(self.success)
5691 
      oprot.writeFieldEnd()
5692 
    if self.cex is not None:
5693 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5694 
      self.cex.write(oprot)
5695 
      oprot.writeFieldEnd()
5696 
    oprot.writeFieldStop()
5697 
    oprot.writeStructEnd()
5698 
 
5699 
  def validate(self):
5700 
    return
5701 
 
5702 
 
5703 
  def __repr__(self):
5704 
    L = ['%s=%r' % (key, value)
5705 
      for key, value in self.__dict__.iteritems()]
5706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5707 
 
5708 
  def __eq__(self, other):
5709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5710 
 
5711 
  def __ne__(self, other):
5712 
    return not (self == other)
5713 
 
5714 
class updateItem_args:
5715 
  """
5716 
  Attributes:
5717 
   - item
5718 
  """
5719 
 
5720 
  thrift_spec = (
5721 
    None, # 0
5722 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5723 
  )
5724 
 
5725 
  def __init__(self, item=None,):
5726 
    self.item = item
5727 
 
5728 
  def read(self, iprot):
5729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5731 
      return
5732 
    iprot.readStructBegin()
5733 
    while True:
5734 
      (fname, ftype, fid) = iprot.readFieldBegin()
5735 
      if ftype == TType.STOP:
5736 
        break
5737 
      if fid == 1:
5738 
        if ftype == TType.STRUCT:
5739 
          self.item = Item()
5740 
          self.item.read(iprot)
5741 
        else:
5742 
          iprot.skip(ftype)
5743 
      else:
5744 
        iprot.skip(ftype)
5745 
      iprot.readFieldEnd()
5746 
    iprot.readStructEnd()
5747 
 
5748 
  def write(self, oprot):
5749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5751 
      return
5752 
    oprot.writeStructBegin('updateItem_args')
5753 
    if self.item is not None:
5754 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5755 
      self.item.write(oprot)
5756 
      oprot.writeFieldEnd()
5757 
    oprot.writeFieldStop()
5758 
    oprot.writeStructEnd()
5759 
 
5760 
  def validate(self):
5761 
    return
5762 
 
5763 
 
5764 
  def __repr__(self):
5765 
    L = ['%s=%r' % (key, value)
5766 
      for key, value in self.__dict__.iteritems()]
5767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5768 
 
5769 
  def __eq__(self, other):
5770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5771 
 
5772 
  def __ne__(self, other):
5773 
    return not (self == other)
5774 
 
5775 
class updateItem_result:
5776 
  """
5777 
  Attributes:
5778 
   - success
5779 
   - cex
5780 
  """
5781 
 
5782 
  thrift_spec = (
5783 
    (0, TType.I64, 'success', None, None, ), # 0
5784 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5785 
  )
5786 
 
5787 
  def __init__(self, success=None, cex=None,):
5788 
    self.success = success
5789 
    self.cex = cex
5790 
 
5791 
  def read(self, iprot):
5792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5794 
      return
5795 
    iprot.readStructBegin()
5796 
    while True:
5797 
      (fname, ftype, fid) = iprot.readFieldBegin()
5798 
      if ftype == TType.STOP:
5799 
        break
5800 
      if fid == 0:
5801 
        if ftype == TType.I64:
5802 
          self.success = iprot.readI64();
5803 
        else:
5804 
          iprot.skip(ftype)
5805 
      elif fid == 1:
5806 
        if ftype == TType.STRUCT:
5807 
          self.cex = CatalogServiceException()
5808 
          self.cex.read(iprot)
5809 
        else:
5810 
          iprot.skip(ftype)
5811 
      else:
5812 
        iprot.skip(ftype)
5813 
      iprot.readFieldEnd()
5814 
    iprot.readStructEnd()
5815 
 
5816 
  def write(self, oprot):
5817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5819 
      return
5820 
    oprot.writeStructBegin('updateItem_result')
5821 
    if self.success is not None:
5822 
      oprot.writeFieldBegin('success', TType.I64, 0)
5823 
      oprot.writeI64(self.success)
5824 
      oprot.writeFieldEnd()
5825 
    if self.cex is not None:
5826 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5827 
      self.cex.write(oprot)
5828 
      oprot.writeFieldEnd()
5829 
    oprot.writeFieldStop()
5830 
    oprot.writeStructEnd()
5831 
 
5832 
  def validate(self):
5833 
    return
5834 
 
5835 
 
5836 
  def __repr__(self):
5837 
    L = ['%s=%r' % (key, value)
5838 
      for key, value in self.__dict__.iteritems()]
5839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5840 
 
5841 
  def __eq__(self, other):
5842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5843 
 
5844 
  def __ne__(self, other):
5845 
    return not (self == other)
5846 
 
5847 
class isActive_args:
5848 
  """
5849 
  Attributes:
5850 
   - itemId
5851 
  """
5852 
 
5853 
  thrift_spec = (
5854 
    None, # 0
5855 
    (1, TType.I64, 'itemId', None, None, ), # 1
5856 
  )
5857 
 
5858 
  def __init__(self, itemId=None,):
5859 
    self.itemId = itemId
5860 
 
5861 
  def read(self, iprot):
5862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5864 
      return
5865 
    iprot.readStructBegin()
5866 
    while True:
5867 
      (fname, ftype, fid) = iprot.readFieldBegin()
5868 
      if ftype == TType.STOP:
5869 
        break
5870 
      if fid == 1:
5871 
        if ftype == TType.I64:
5872 
          self.itemId = iprot.readI64();
5873 
        else:
5874 
          iprot.skip(ftype)
5875 
      else:
5876 
        iprot.skip(ftype)
5877 
      iprot.readFieldEnd()
5878 
    iprot.readStructEnd()
5879 
 
5880 
  def write(self, oprot):
5881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5883 
      return
5884 
    oprot.writeStructBegin('isActive_args')
5885 
    if self.itemId is not None:
5886 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5887 
      oprot.writeI64(self.itemId)
5888 
      oprot.writeFieldEnd()
5889 
    oprot.writeFieldStop()
5890 
    oprot.writeStructEnd()
5891 
 
5892 
  def validate(self):
5893 
    return
5894 
 
5895 
 
5896 
  def __repr__(self):
5897 
    L = ['%s=%r' % (key, value)
5898 
      for key, value in self.__dict__.iteritems()]
5899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5900 
 
5901 
  def __eq__(self, other):
5902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5903 
 
5904 
  def __ne__(self, other):
5905 
    return not (self == other)
5906 
 
5907 
class isActive_result:
5908 
  """
5909 
  Attributes:
5910 
   - success
5911 
   - isex
5912 
  """
5913 
 
5914 
  thrift_spec = (
5915 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5916 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5917 
  )
5918 
 
5919 
  def __init__(self, success=None, isex=None,):
5920 
    self.success = success
5921 
    self.isex = isex
5922 
 
5923 
  def read(self, iprot):
5924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5926 
      return
5927 
    iprot.readStructBegin()
5928 
    while True:
5929 
      (fname, ftype, fid) = iprot.readFieldBegin()
5930 
      if ftype == TType.STOP:
5931 
        break
5932 
      if fid == 0:
5933 
        if ftype == TType.STRUCT:
5934 
          self.success = ItemShippingInfo()
5935 
          self.success.read(iprot)
5936 
        else:
5937 
          iprot.skip(ftype)
5938 
      elif fid == 1:
5939 
        if ftype == TType.STRUCT:
5940 
          self.isex = CatalogServiceException()
5941 
          self.isex.read(iprot)
5942 
        else:
5943 
          iprot.skip(ftype)
5944 
      else:
5945 
        iprot.skip(ftype)
5946 
      iprot.readFieldEnd()
5947 
    iprot.readStructEnd()
5948 
 
5949 
  def write(self, oprot):
5950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5952 
      return
5953 
    oprot.writeStructBegin('isActive_result')
5954 
    if self.success is not None:
5955 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5956 
      self.success.write(oprot)
5957 
      oprot.writeFieldEnd()
5958 
    if self.isex is not None:
5959 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5960 
      self.isex.write(oprot)
5961 
      oprot.writeFieldEnd()
5962 
    oprot.writeFieldStop()
5963 
    oprot.writeStructEnd()
5964 
 
5965 
  def validate(self):
5966 
    return
5967 
 
5968 
 
5969 
  def __repr__(self):
5970 
    L = ['%s=%r' % (key, value)
5971 
      for key, value in self.__dict__.iteritems()]
5972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5973 
 
5974 
  def __eq__(self, other):
5975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5976 
 
5977 
  def __ne__(self, other):
5978 
    return not (self == other)
5979 
 
7438 amit.gupta 5980 
class getItemsStatus_args:
5981 
  """
5982 
  Attributes:
5983 
   - itemIds
5984 
  """
5985 
 
5986 
  thrift_spec = (
5987 
    None, # 0
5988 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5989 
  )
5990 
 
5991 
  def __init__(self, itemIds=None,):
5992 
    self.itemIds = itemIds
5993 
 
5994 
  def read(self, iprot):
5995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5997 
      return
5998 
    iprot.readStructBegin()
5999 
    while True:
6000 
      (fname, ftype, fid) = iprot.readFieldBegin()
6001 
      if ftype == TType.STOP:
6002 
        break
6003 
      if fid == 1:
6004 
        if ftype == TType.LIST:
6005 
          self.itemIds = []
6006 
          (_etype19, _size16) = iprot.readListBegin()
6007 
          for _i20 in xrange(_size16):
6008 
            _elem21 = iprot.readI64();
6009 
            self.itemIds.append(_elem21)
6010 
          iprot.readListEnd()
6011 
        else:
6012 
          iprot.skip(ftype)
6013 
      else:
6014 
        iprot.skip(ftype)
6015 
      iprot.readFieldEnd()
6016 
    iprot.readStructEnd()
6017 
 
6018 
  def write(self, oprot):
6019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6021 
      return
6022 
    oprot.writeStructBegin('getItemsStatus_args')
6023 
    if self.itemIds is not None:
6024 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6025 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6026 
      for iter22 in self.itemIds:
6027 
        oprot.writeI64(iter22)
6028 
      oprot.writeListEnd()
6029 
      oprot.writeFieldEnd()
6030 
    oprot.writeFieldStop()
6031 
    oprot.writeStructEnd()
6032 
 
6033 
  def validate(self):
6034 
    return
6035 
 
6036 
 
6037 
  def __repr__(self):
6038 
    L = ['%s=%r' % (key, value)
6039 
      for key, value in self.__dict__.iteritems()]
6040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6041 
 
6042 
  def __eq__(self, other):
6043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6044 
 
6045 
  def __ne__(self, other):
6046 
    return not (self == other)
6047 
 
6048 
class getItemsStatus_result:
6049 
  """
6050 
  Attributes:
6051 
   - success
6052 
   - isex
6053 
  """
6054 
 
6055 
  thrift_spec = (
6056 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6057 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6058 
  )
6059 
 
6060 
  def __init__(self, success=None, isex=None,):
6061 
    self.success = success
6062 
    self.isex = isex
6063 
 
6064 
  def read(self, iprot):
6065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6067 
      return
6068 
    iprot.readStructBegin()
6069 
    while True:
6070 
      (fname, ftype, fid) = iprot.readFieldBegin()
6071 
      if ftype == TType.STOP:
6072 
        break
6073 
      if fid == 0:
6074 
        if ftype == TType.MAP:
6075 
          self.success = {}
6076 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
6077 
          for _i27 in xrange(_size23):
6078 
            _key28 = iprot.readI64();
6079 
            _val29 = iprot.readBool();
6080 
            self.success[_key28] = _val29
6081 
          iprot.readMapEnd()
6082 
        else:
6083 
          iprot.skip(ftype)
6084 
      elif fid == 1:
6085 
        if ftype == TType.STRUCT:
6086 
          self.isex = CatalogServiceException()
6087 
          self.isex.read(iprot)
6088 
        else:
6089 
          iprot.skip(ftype)
6090 
      else:
6091 
        iprot.skip(ftype)
6092 
      iprot.readFieldEnd()
6093 
    iprot.readStructEnd()
6094 
 
6095 
  def write(self, oprot):
6096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6098 
      return
6099 
    oprot.writeStructBegin('getItemsStatus_result')
6100 
    if self.success is not None:
6101 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6102 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
6103 
      for kiter30,viter31 in self.success.items():
6104 
        oprot.writeI64(kiter30)
6105 
        oprot.writeBool(viter31)
6106 
      oprot.writeMapEnd()
6107 
      oprot.writeFieldEnd()
6108 
    if self.isex is not None:
6109 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6110 
      self.isex.write(oprot)
6111 
      oprot.writeFieldEnd()
6112 
    oprot.writeFieldStop()
6113 
    oprot.writeStructEnd()
6114 
 
6115 
  def validate(self):
6116 
    return
6117 
 
6118 
 
6119 
  def __repr__(self):
6120 
    L = ['%s=%r' % (key, value)
6121 
      for key, value in self.__dict__.iteritems()]
6122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6123 
 
6124 
  def __eq__(self, other):
6125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6126 
 
6127 
  def __ne__(self, other):
6128 
    return not (self == other)
6129 
 
5944 mandeep.dh 6130 
class getItemStatusDescription_args:
6131 
  """
6132 
  Attributes:
6133 
   - itemId
6134 
  """
6135 
 
6136 
  thrift_spec = (
6137 
    None, # 0
6138 
    (1, TType.I64, 'itemId', None, None, ), # 1
6139 
  )
6140 
 
6141 
  def __init__(self, itemId=None,):
6142 
    self.itemId = itemId
6143 
 
6144 
  def read(self, iprot):
6145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6147 
      return
6148 
    iprot.readStructBegin()
6149 
    while True:
6150 
      (fname, ftype, fid) = iprot.readFieldBegin()
6151 
      if ftype == TType.STOP:
6152 
        break
6153 
      if fid == 1:
6154 
        if ftype == TType.I64:
6155 
          self.itemId = iprot.readI64();
6156 
        else:
6157 
          iprot.skip(ftype)
6158 
      else:
6159 
        iprot.skip(ftype)
6160 
      iprot.readFieldEnd()
6161 
    iprot.readStructEnd()
6162 
 
6163 
  def write(self, oprot):
6164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6166 
      return
6167 
    oprot.writeStructBegin('getItemStatusDescription_args')
6168 
    if self.itemId is not None:
6169 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6170 
      oprot.writeI64(self.itemId)
6171 
      oprot.writeFieldEnd()
6172 
    oprot.writeFieldStop()
6173 
    oprot.writeStructEnd()
6174 
 
6175 
  def validate(self):
6176 
    return
6177 
 
6178 
 
6179 
  def __repr__(self):
6180 
    L = ['%s=%r' % (key, value)
6181 
      for key, value in self.__dict__.iteritems()]
6182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6183 
 
6184 
  def __eq__(self, other):
6185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6186 
 
6187 
  def __ne__(self, other):
6188 
    return not (self == other)
6189 
 
6190 
class getItemStatusDescription_result:
6191 
  """
6192 
  Attributes:
6193 
   - success
6194 
   - isex
6195 
  """
6196 
 
6197 
  thrift_spec = (
6198 
    (0, TType.STRING, 'success', None, None, ), # 0
6199 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6200 
  )
6201 
 
6202 
  def __init__(self, success=None, isex=None,):
6203 
    self.success = success
6204 
    self.isex = isex
6205 
 
6206 
  def read(self, iprot):
6207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6209 
      return
6210 
    iprot.readStructBegin()
6211 
    while True:
6212 
      (fname, ftype, fid) = iprot.readFieldBegin()
6213 
      if ftype == TType.STOP:
6214 
        break
6215 
      if fid == 0:
6216 
        if ftype == TType.STRING:
6217 
          self.success = iprot.readString();
6218 
        else:
6219 
          iprot.skip(ftype)
6220 
      elif fid == 1:
6221 
        if ftype == TType.STRUCT:
6222 
          self.isex = CatalogServiceException()
6223 
          self.isex.read(iprot)
6224 
        else:
6225 
          iprot.skip(ftype)
6226 
      else:
6227 
        iprot.skip(ftype)
6228 
      iprot.readFieldEnd()
6229 
    iprot.readStructEnd()
6230 
 
6231 
  def write(self, oprot):
6232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6234 
      return
6235 
    oprot.writeStructBegin('getItemStatusDescription_result')
6236 
    if self.success is not None:
6237 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6238 
      oprot.writeString(self.success)
6239 
      oprot.writeFieldEnd()
6240 
    if self.isex is not None:
6241 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6242 
      self.isex.write(oprot)
6243 
      oprot.writeFieldEnd()
6244 
    oprot.writeFieldStop()
6245 
    oprot.writeStructEnd()
6246 
 
6247 
  def validate(self):
6248 
    return
6249 
 
6250 
 
6251 
  def __repr__(self):
6252 
    L = ['%s=%r' % (key, value)
6253 
      for key, value in self.__dict__.iteritems()]
6254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6255 
 
6256 
  def __eq__(self, other):
6257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6258 
 
6259 
  def __ne__(self, other):
6260 
    return not (self == other)
6261 
 
6262 
class startItemOn_args:
6263 
  """
6264 
  Attributes:
6265 
   - item_id
6266 
   - timestamp
6267 
  """
6268 
 
6269 
  thrift_spec = (
6270 
    None, # 0
6271 
    (1, TType.I64, 'item_id', None, None, ), # 1
6272 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6273 
  )
6274 
 
6275 
  def __init__(self, item_id=None, timestamp=None,):
6276 
    self.item_id = item_id
6277 
    self.timestamp = timestamp
6278 
 
6279 
  def read(self, iprot):
6280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6282 
      return
6283 
    iprot.readStructBegin()
6284 
    while True:
6285 
      (fname, ftype, fid) = iprot.readFieldBegin()
6286 
      if ftype == TType.STOP:
6287 
        break
6288 
      if fid == 1:
6289 
        if ftype == TType.I64:
6290 
          self.item_id = iprot.readI64();
6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      elif fid == 2:
6294 
        if ftype == TType.I64:
6295 
          self.timestamp = iprot.readI64();
6296 
        else:
6297 
          iprot.skip(ftype)
6298 
      else:
6299 
        iprot.skip(ftype)
6300 
      iprot.readFieldEnd()
6301 
    iprot.readStructEnd()
6302 
 
6303 
  def write(self, oprot):
6304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6306 
      return
6307 
    oprot.writeStructBegin('startItemOn_args')
6308 
    if self.item_id is not None:
6309 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6310 
      oprot.writeI64(self.item_id)
6311 
      oprot.writeFieldEnd()
6312 
    if self.timestamp is not None:
6313 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6314 
      oprot.writeI64(self.timestamp)
6315 
      oprot.writeFieldEnd()
6316 
    oprot.writeFieldStop()
6317 
    oprot.writeStructEnd()
6318 
 
6319 
  def validate(self):
6320 
    return
6321 
 
6322 
 
6323 
  def __repr__(self):
6324 
    L = ['%s=%r' % (key, value)
6325 
      for key, value in self.__dict__.iteritems()]
6326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6327 
 
6328 
  def __eq__(self, other):
6329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6330 
 
6331 
  def __ne__(self, other):
6332 
    return not (self == other)
6333 
 
6334 
class startItemOn_result:
6335 
  """
6336 
  Attributes:
6337 
   - cex
6338 
  """
6339 
 
6340 
  thrift_spec = (
6341 
    None, # 0
6342 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6343 
  )
6344 
 
6345 
  def __init__(self, cex=None,):
6346 
    self.cex = cex
6347 
 
6348 
  def read(self, iprot):
6349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6351 
      return
6352 
    iprot.readStructBegin()
6353 
    while True:
6354 
      (fname, ftype, fid) = iprot.readFieldBegin()
6355 
      if ftype == TType.STOP:
6356 
        break
6357 
      if fid == 1:
6358 
        if ftype == TType.STRUCT:
6359 
          self.cex = CatalogServiceException()
6360 
          self.cex.read(iprot)
6361 
        else:
6362 
          iprot.skip(ftype)
6363 
      else:
6364 
        iprot.skip(ftype)
6365 
      iprot.readFieldEnd()
6366 
    iprot.readStructEnd()
6367 
 
6368 
  def write(self, oprot):
6369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6371 
      return
6372 
    oprot.writeStructBegin('startItemOn_result')
6373 
    if self.cex is not None:
6374 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6375 
      self.cex.write(oprot)
6376 
      oprot.writeFieldEnd()
6377 
    oprot.writeFieldStop()
6378 
    oprot.writeStructEnd()
6379 
 
6380 
  def validate(self):
6381 
    return
6382 
 
6383 
 
6384 
  def __repr__(self):
6385 
    L = ['%s=%r' % (key, value)
6386 
      for key, value in self.__dict__.iteritems()]
6387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6388 
 
6389 
  def __eq__(self, other):
6390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6391 
 
6392 
  def __ne__(self, other):
6393 
    return not (self == other)
6394 
 
6395 
class retireItemOn_args:
6396 
  """
6397 
  Attributes:
6398 
   - item_id
6399 
   - timestamp
6400 
  """
6401 
 
6402 
  thrift_spec = (
6403 
    None, # 0
6404 
    (1, TType.I64, 'item_id', None, None, ), # 1
6405 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6406 
  )
6407 
 
6408 
  def __init__(self, item_id=None, timestamp=None,):
6409 
    self.item_id = item_id
6410 
    self.timestamp = timestamp
6411 
 
6412 
  def read(self, iprot):
6413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6415 
      return
6416 
    iprot.readStructBegin()
6417 
    while True:
6418 
      (fname, ftype, fid) = iprot.readFieldBegin()
6419 
      if ftype == TType.STOP:
6420 
        break
6421 
      if fid == 1:
6422 
        if ftype == TType.I64:
6423 
          self.item_id = iprot.readI64();
6424 
        else:
6425 
          iprot.skip(ftype)
6426 
      elif fid == 2:
6427 
        if ftype == TType.I64:
6428 
          self.timestamp = iprot.readI64();
6429 
        else:
6430 
          iprot.skip(ftype)
6431 
      else:
6432 
        iprot.skip(ftype)
6433 
      iprot.readFieldEnd()
6434 
    iprot.readStructEnd()
6435 
 
6436 
  def write(self, oprot):
6437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6439 
      return
6440 
    oprot.writeStructBegin('retireItemOn_args')
6441 
    if self.item_id is not None:
6442 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6443 
      oprot.writeI64(self.item_id)
6444 
      oprot.writeFieldEnd()
6445 
    if self.timestamp is not None:
6446 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6447 
      oprot.writeI64(self.timestamp)
6448 
      oprot.writeFieldEnd()
6449 
    oprot.writeFieldStop()
6450 
    oprot.writeStructEnd()
6451 
 
6452 
  def validate(self):
6453 
    return
6454 
 
6455 
 
6456 
  def __repr__(self):
6457 
    L = ['%s=%r' % (key, value)
6458 
      for key, value in self.__dict__.iteritems()]
6459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6460 
 
6461 
  def __eq__(self, other):
6462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6463 
 
6464 
  def __ne__(self, other):
6465 
    return not (self == other)
6466 
 
6467 
class retireItemOn_result:
6468 
  """
6469 
  Attributes:
6470 
   - cex
6471 
  """
6472 
 
6473 
  thrift_spec = (
6474 
    None, # 0
6475 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6476 
  )
6477 
 
6478 
  def __init__(self, cex=None,):
6479 
    self.cex = cex
6480 
 
6481 
  def read(self, iprot):
6482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6484 
      return
6485 
    iprot.readStructBegin()
6486 
    while True:
6487 
      (fname, ftype, fid) = iprot.readFieldBegin()
6488 
      if ftype == TType.STOP:
6489 
        break
6490 
      if fid == 1:
6491 
        if ftype == TType.STRUCT:
6492 
          self.cex = CatalogServiceException()
6493 
          self.cex.read(iprot)
6494 
        else:
6495 
          iprot.skip(ftype)
6496 
      else:
6497 
        iprot.skip(ftype)
6498 
      iprot.readFieldEnd()
6499 
    iprot.readStructEnd()
6500 
 
6501 
  def write(self, oprot):
6502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6504 
      return
6505 
    oprot.writeStructBegin('retireItemOn_result')
6506 
    if self.cex is not None:
6507 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6508 
      self.cex.write(oprot)
6509 
      oprot.writeFieldEnd()
6510 
    oprot.writeFieldStop()
6511 
    oprot.writeStructEnd()
6512 
 
6513 
  def validate(self):
6514 
    return
6515 
 
6516 
 
6517 
  def __repr__(self):
6518 
    L = ['%s=%r' % (key, value)
6519 
      for key, value in self.__dict__.iteritems()]
6520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6521 
 
6522 
  def __eq__(self, other):
6523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6524 
 
6525 
  def __ne__(self, other):
6526 
    return not (self == other)
6527 
 
6528 
class changeItemStatus_args:
6529 
  """
6530 
  Attributes:
6531 
   - item_id
6532 
   - timestamp
6533 
   - newstatus
6534 
  """
6535 
 
6536 
  thrift_spec = (
6537 
    None, # 0
6538 
    (1, TType.I64, 'item_id', None, None, ), # 1
6539 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6540 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6541 
  )
6542 
 
6543 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6544 
    self.item_id = item_id
6545 
    self.timestamp = timestamp
6546 
    self.newstatus = newstatus
6547 
 
6548 
  def read(self, iprot):
6549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6551 
      return
6552 
    iprot.readStructBegin()
6553 
    while True:
6554 
      (fname, ftype, fid) = iprot.readFieldBegin()
6555 
      if ftype == TType.STOP:
6556 
        break
6557 
      if fid == 1:
6558 
        if ftype == TType.I64:
6559 
          self.item_id = iprot.readI64();
6560 
        else:
6561 
          iprot.skip(ftype)
6562 
      elif fid == 2:
6563 
        if ftype == TType.I64:
6564 
          self.timestamp = iprot.readI64();
6565 
        else:
6566 
          iprot.skip(ftype)
6567 
      elif fid == 3:
6568 
        if ftype == TType.I32:
6569 
          self.newstatus = iprot.readI32();
6570 
        else:
6571 
          iprot.skip(ftype)
6572 
      else:
6573 
        iprot.skip(ftype)
6574 
      iprot.readFieldEnd()
6575 
    iprot.readStructEnd()
6576 
 
6577 
  def write(self, oprot):
6578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6580 
      return
6581 
    oprot.writeStructBegin('changeItemStatus_args')
6582 
    if self.item_id is not None:
6583 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6584 
      oprot.writeI64(self.item_id)
6585 
      oprot.writeFieldEnd()
6586 
    if self.timestamp is not None:
6587 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6588 
      oprot.writeI64(self.timestamp)
6589 
      oprot.writeFieldEnd()
6590 
    if self.newstatus is not None:
6591 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6592 
      oprot.writeI32(self.newstatus)
6593 
      oprot.writeFieldEnd()
6594 
    oprot.writeFieldStop()
6595 
    oprot.writeStructEnd()
6596 
 
6597 
  def validate(self):
6598 
    return
6599 
 
6600 
 
6601 
  def __repr__(self):
6602 
    L = ['%s=%r' % (key, value)
6603 
      for key, value in self.__dict__.iteritems()]
6604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6605 
 
6606 
  def __eq__(self, other):
6607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6608 
 
6609 
  def __ne__(self, other):
6610 
    return not (self == other)
6611 
 
6612 
class changeItemStatus_result:
6613 
  """
6614 
  Attributes:
6615 
   - cex
6616 
  """
6617 
 
6618 
  thrift_spec = (
6619 
    None, # 0
6620 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6621 
  )
6622 
 
6623 
  def __init__(self, cex=None,):
6624 
    self.cex = cex
6625 
 
6626 
  def read(self, iprot):
6627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6629 
      return
6630 
    iprot.readStructBegin()
6631 
    while True:
6632 
      (fname, ftype, fid) = iprot.readFieldBegin()
6633 
      if ftype == TType.STOP:
6634 
        break
6635 
      if fid == 1:
6636 
        if ftype == TType.STRUCT:
6637 
          self.cex = CatalogServiceException()
6638 
          self.cex.read(iprot)
6639 
        else:
6640 
          iprot.skip(ftype)
6641 
      else:
6642 
        iprot.skip(ftype)
6643 
      iprot.readFieldEnd()
6644 
    iprot.readStructEnd()
6645 
 
6646 
  def write(self, oprot):
6647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6649 
      return
6650 
    oprot.writeStructBegin('changeItemStatus_result')
6651 
    if self.cex is not None:
6652 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6653 
      self.cex.write(oprot)
6654 
      oprot.writeFieldEnd()
6655 
    oprot.writeFieldStop()
6656 
    oprot.writeStructEnd()
6657 
 
6658 
  def validate(self):
6659 
    return
6660 
 
6661 
 
6662 
  def __repr__(self):
6663 
    L = ['%s=%r' % (key, value)
6664 
      for key, value in self.__dict__.iteritems()]
6665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6666 
 
6667 
  def __eq__(self, other):
6668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6669 
 
6670 
  def __ne__(self, other):
6671 
    return not (self == other)
6672 
 
6673 
class getItem_args:
6674 
  """
6675 
  Attributes:
6676 
   - item_id
6677 
  """
6678 
 
6679 
  thrift_spec = (
6680 
    None, # 0
6681 
    (1, TType.I64, 'item_id', None, None, ), # 1
6682 
  )
6683 
 
6684 
  def __init__(self, item_id=None,):
6685 
    self.item_id = item_id
6686 
 
6687 
  def read(self, iprot):
6688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6690 
      return
6691 
    iprot.readStructBegin()
6692 
    while True:
6693 
      (fname, ftype, fid) = iprot.readFieldBegin()
6694 
      if ftype == TType.STOP:
6695 
        break
6696 
      if fid == 1:
6697 
        if ftype == TType.I64:
6698 
          self.item_id = iprot.readI64();
6699 
        else:
6700 
          iprot.skip(ftype)
6701 
      else:
6702 
        iprot.skip(ftype)
6703 
      iprot.readFieldEnd()
6704 
    iprot.readStructEnd()
6705 
 
6706 
  def write(self, oprot):
6707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6709 
      return
6710 
    oprot.writeStructBegin('getItem_args')
6711 
    if self.item_id is not None:
6712 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6713 
      oprot.writeI64(self.item_id)
6714 
      oprot.writeFieldEnd()
6715 
    oprot.writeFieldStop()
6716 
    oprot.writeStructEnd()
6717 
 
6718 
  def validate(self):
6719 
    return
6720 
 
6721 
 
6722 
  def __repr__(self):
6723 
    L = ['%s=%r' % (key, value)
6724 
      for key, value in self.__dict__.iteritems()]
6725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6726 
 
6727 
  def __eq__(self, other):
6728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6729 
 
6730 
  def __ne__(self, other):
6731 
    return not (self == other)
6732 
 
6733 
class getItem_result:
6734 
  """
6735 
  Attributes:
6736 
   - success
6737 
   - cex
6738 
  """
6739 
 
6740 
  thrift_spec = (
6741 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6742 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6743 
  )
6744 
 
6745 
  def __init__(self, success=None, cex=None,):
6746 
    self.success = success
6747 
    self.cex = cex
6748 
 
6749 
  def read(self, iprot):
6750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6752 
      return
6753 
    iprot.readStructBegin()
6754 
    while True:
6755 
      (fname, ftype, fid) = iprot.readFieldBegin()
6756 
      if ftype == TType.STOP:
6757 
        break
6758 
      if fid == 0:
6759 
        if ftype == TType.STRUCT:
6760 
          self.success = Item()
6761 
          self.success.read(iprot)
6762 
        else:
6763 
          iprot.skip(ftype)
6764 
      elif fid == 1:
6765 
        if ftype == TType.STRUCT:
6766 
          self.cex = CatalogServiceException()
6767 
          self.cex.read(iprot)
6768 
        else:
6769 
          iprot.skip(ftype)
6770 
      else:
6771 
        iprot.skip(ftype)
6772 
      iprot.readFieldEnd()
6773 
    iprot.readStructEnd()
6774 
 
6775 
  def write(self, oprot):
6776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6778 
      return
6779 
    oprot.writeStructBegin('getItem_result')
6780 
    if self.success is not None:
6781 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6782 
      self.success.write(oprot)
6783 
      oprot.writeFieldEnd()
6784 
    if self.cex is not None:
6785 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6786 
      self.cex.write(oprot)
6787 
      oprot.writeFieldEnd()
6788 
    oprot.writeFieldStop()
6789 
    oprot.writeStructEnd()
6790 
 
6791 
  def validate(self):
6792 
    return
6793 
 
6794 
 
6795 
  def __repr__(self):
6796 
    L = ['%s=%r' % (key, value)
6797 
      for key, value in self.__dict__.iteritems()]
6798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6799 
 
6800 
  def __eq__(self, other):
6801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6802 
 
6803 
  def __ne__(self, other):
6804 
    return not (self == other)
6805 
 
6806 
class getItemsByCatalogId_args:
6807 
  """
6808 
  Attributes:
6809 
   - catalog_item_id
6810 
  """
6811 
 
6812 
  thrift_spec = (
6813 
    None, # 0
6814 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6815 
  )
6816 
 
6817 
  def __init__(self, catalog_item_id=None,):
6818 
    self.catalog_item_id = catalog_item_id
6819 
 
6820 
  def read(self, iprot):
6821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6823 
      return
6824 
    iprot.readStructBegin()
6825 
    while True:
6826 
      (fname, ftype, fid) = iprot.readFieldBegin()
6827 
      if ftype == TType.STOP:
6828 
        break
6829 
      if fid == 1:
6830 
        if ftype == TType.I64:
6831 
          self.catalog_item_id = iprot.readI64();
6832 
        else:
6833 
          iprot.skip(ftype)
6834 
      else:
6835 
        iprot.skip(ftype)
6836 
      iprot.readFieldEnd()
6837 
    iprot.readStructEnd()
6838 
 
6839 
  def write(self, oprot):
6840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6842 
      return
6843 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6844 
    if self.catalog_item_id is not None:
6845 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6846 
      oprot.writeI64(self.catalog_item_id)
6847 
      oprot.writeFieldEnd()
6848 
    oprot.writeFieldStop()
6849 
    oprot.writeStructEnd()
6850 
 
6851 
  def validate(self):
6852 
    return
6853 
 
6854 
 
6855 
  def __repr__(self):
6856 
    L = ['%s=%r' % (key, value)
6857 
      for key, value in self.__dict__.iteritems()]
6858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6859 
 
6860 
  def __eq__(self, other):
6861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6862 
 
6863 
  def __ne__(self, other):
6864 
    return not (self == other)
6865 
 
6866 
class getItemsByCatalogId_result:
6867 
  """
6868 
  Attributes:
6869 
   - success
6870 
   - cex
6871 
  """
6872 
 
6873 
  thrift_spec = (
6874 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6875 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6876 
  )
6877 
 
6878 
  def __init__(self, success=None, cex=None,):
6879 
    self.success = success
6880 
    self.cex = cex
6881 
 
6882 
  def read(self, iprot):
6883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6885 
      return
6886 
    iprot.readStructBegin()
6887 
    while True:
6888 
      (fname, ftype, fid) = iprot.readFieldBegin()
6889 
      if ftype == TType.STOP:
6890 
        break
6891 
      if fid == 0:
6892 
        if ftype == TType.LIST:
6893 
          self.success = []
7438 amit.gupta 6894 
          (_etype35, _size32) = iprot.readListBegin()
6895 
          for _i36 in xrange(_size32):
6896 
            _elem37 = Item()
6897 
            _elem37.read(iprot)
6898 
            self.success.append(_elem37)
5944 mandeep.dh 6899 
          iprot.readListEnd()
6900 
        else:
6901 
          iprot.skip(ftype)
6902 
      elif fid == 1:
6903 
        if ftype == TType.STRUCT:
6904 
          self.cex = CatalogServiceException()
6905 
          self.cex.read(iprot)
6906 
        else:
6907 
          iprot.skip(ftype)
6908 
      else:
6909 
        iprot.skip(ftype)
6910 
      iprot.readFieldEnd()
6911 
    iprot.readStructEnd()
6912 
 
6913 
  def write(self, oprot):
6914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6916 
      return
6917 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6918 
    if self.success is not None:
6919 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6920 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6921 
      for iter38 in self.success:
6922 
        iter38.write(oprot)
5944 mandeep.dh 6923 
      oprot.writeListEnd()
6924 
      oprot.writeFieldEnd()
6925 
    if self.cex is not None:
6926 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6927 
      self.cex.write(oprot)
6928 
      oprot.writeFieldEnd()
6929 
    oprot.writeFieldStop()
6930 
    oprot.writeStructEnd()
6931 
 
6932 
  def validate(self):
6933 
    return
6934 
 
6935 
 
6936 
  def __repr__(self):
6937 
    L = ['%s=%r' % (key, value)
6938 
      for key, value in self.__dict__.iteritems()]
6939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6940 
 
6941 
  def __eq__(self, other):
6942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6943 
 
6944 
  def __ne__(self, other):
6945 
    return not (self == other)
6946 
 
6947 
class getValidItemsByCatalogId_args:
6948 
  """
6949 
  Attributes:
6950 
   - catalog_item_id
6951 
  """
6952 
 
6953 
  thrift_spec = (
6954 
    None, # 0
6955 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6956 
  )
6957 
 
6958 
  def __init__(self, catalog_item_id=None,):
6959 
    self.catalog_item_id = catalog_item_id
6960 
 
6961 
  def read(self, iprot):
6962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6964 
      return
6965 
    iprot.readStructBegin()
6966 
    while True:
6967 
      (fname, ftype, fid) = iprot.readFieldBegin()
6968 
      if ftype == TType.STOP:
6969 
        break
6970 
      if fid == 1:
6971 
        if ftype == TType.I64:
6972 
          self.catalog_item_id = iprot.readI64();
6973 
        else:
6974 
          iprot.skip(ftype)
6975 
      else:
6976 
        iprot.skip(ftype)
6977 
      iprot.readFieldEnd()
6978 
    iprot.readStructEnd()
6979 
 
6980 
  def write(self, oprot):
6981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6983 
      return
6984 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6985 
    if self.catalog_item_id is not None:
6986 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6987 
      oprot.writeI64(self.catalog_item_id)
6988 
      oprot.writeFieldEnd()
6989 
    oprot.writeFieldStop()
6990 
    oprot.writeStructEnd()
6991 
 
6992 
  def validate(self):
6993 
    return
6994 
 
6995 
 
6996 
  def __repr__(self):
6997 
    L = ['%s=%r' % (key, value)
6998 
      for key, value in self.__dict__.iteritems()]
6999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7000 
 
7001 
  def __eq__(self, other):
7002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7003 
 
7004 
  def __ne__(self, other):
7005 
    return not (self == other)
7006 
 
7007 
class getValidItemsByCatalogId_result:
7008 
  """
7009 
  Attributes:
7010 
   - success
7011 
   - cex
7012 
  """
7013 
 
7014 
  thrift_spec = (
7015 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7016 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7017 
  )
7018 
 
7019 
  def __init__(self, success=None, cex=None,):
7020 
    self.success = success
7021 
    self.cex = cex
7022 
 
7023 
  def read(self, iprot):
7024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7026 
      return
7027 
    iprot.readStructBegin()
7028 
    while True:
7029 
      (fname, ftype, fid) = iprot.readFieldBegin()
7030 
      if ftype == TType.STOP:
7031 
        break
7032 
      if fid == 0:
7033 
        if ftype == TType.LIST:
7034 
          self.success = []
7438 amit.gupta 7035 
          (_etype42, _size39) = iprot.readListBegin()
7036 
          for _i43 in xrange(_size39):
7037 
            _elem44 = Item()
7038 
            _elem44.read(iprot)
7039 
            self.success.append(_elem44)
5944 mandeep.dh 7040 
          iprot.readListEnd()
7041 
        else:
7042 
          iprot.skip(ftype)
7043 
      elif fid == 1:
7044 
        if ftype == TType.STRUCT:
7045 
          self.cex = CatalogServiceException()
7046 
          self.cex.read(iprot)
7047 
        else:
7048 
          iprot.skip(ftype)
7049 
      else:
7050 
        iprot.skip(ftype)
7051 
      iprot.readFieldEnd()
7052 
    iprot.readStructEnd()
7053 
 
7054 
  def write(self, oprot):
7055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7057 
      return
7058 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7059 
    if self.success is not None:
7060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7062 
      for iter45 in self.success:
7063 
        iter45.write(oprot)
5944 mandeep.dh 7064 
      oprot.writeListEnd()
7065 
      oprot.writeFieldEnd()
7066 
    if self.cex is not None:
7067 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7068 
      self.cex.write(oprot)
7069 
      oprot.writeFieldEnd()
7070 
    oprot.writeFieldStop()
7071 
    oprot.writeStructEnd()
7072 
 
7073 
  def validate(self):
7074 
    return
7075 
 
7076 
 
7077 
  def __repr__(self):
7078 
    L = ['%s=%r' % (key, value)
7079 
      for key, value in self.__dict__.iteritems()]
7080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7081 
 
7082 
  def __eq__(self, other):
7083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7084 
 
7085 
  def __ne__(self, other):
7086 
    return not (self == other)
7087 
 
7088 
class getAllItems_args:
7089 
  """
7090 
  Attributes:
7091 
   - isActive
7092 
  """
7093 
 
7094 
  thrift_spec = (
7095 
    None, # 0
7096 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7097 
  )
7098 
 
7099 
  def __init__(self, isActive=None,):
7100 
    self.isActive = isActive
7101 
 
7102 
  def read(self, iprot):
7103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7105 
      return
7106 
    iprot.readStructBegin()
7107 
    while True:
7108 
      (fname, ftype, fid) = iprot.readFieldBegin()
7109 
      if ftype == TType.STOP:
7110 
        break
7111 
      if fid == 1:
7112 
        if ftype == TType.BOOL:
7113 
          self.isActive = iprot.readBool();
7114 
        else:
7115 
          iprot.skip(ftype)
7116 
      else:
7117 
        iprot.skip(ftype)
7118 
      iprot.readFieldEnd()
7119 
    iprot.readStructEnd()
7120 
 
7121 
  def write(self, oprot):
7122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7124 
      return
7125 
    oprot.writeStructBegin('getAllItems_args')
7126 
    if self.isActive is not None:
7127 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7128 
      oprot.writeBool(self.isActive)
7129 
      oprot.writeFieldEnd()
7130 
    oprot.writeFieldStop()
7131 
    oprot.writeStructEnd()
7132 
 
7133 
  def validate(self):
7134 
    return
7135 
 
7136 
 
7137 
  def __repr__(self):
7138 
    L = ['%s=%r' % (key, value)
7139 
      for key, value in self.__dict__.iteritems()]
7140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7141 
 
7142 
  def __eq__(self, other):
7143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7144 
 
7145 
  def __ne__(self, other):
7146 
    return not (self == other)
7147 
 
7148 
class getAllItems_result:
7149 
  """
7150 
  Attributes:
7151 
   - success
7152 
   - cex
7153 
  """
7154 
 
7155 
  thrift_spec = (
7156 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7157 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7158 
  )
7159 
 
7160 
  def __init__(self, success=None, cex=None,):
7161 
    self.success = success
7162 
    self.cex = cex
7163 
 
7164 
  def read(self, iprot):
7165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7167 
      return
7168 
    iprot.readStructBegin()
7169 
    while True:
7170 
      (fname, ftype, fid) = iprot.readFieldBegin()
7171 
      if ftype == TType.STOP:
7172 
        break
7173 
      if fid == 0:
7174 
        if ftype == TType.LIST:
7175 
          self.success = []
7438 amit.gupta 7176 
          (_etype49, _size46) = iprot.readListBegin()
7177 
          for _i50 in xrange(_size46):
7178 
            _elem51 = Item()
7179 
            _elem51.read(iprot)
7180 
            self.success.append(_elem51)
5944 mandeep.dh 7181 
          iprot.readListEnd()
7182 
        else:
7183 
          iprot.skip(ftype)
7184 
      elif fid == 1:
7185 
        if ftype == TType.STRUCT:
7186 
          self.cex = CatalogServiceException()
7187 
          self.cex.read(iprot)
7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      else:
7191 
        iprot.skip(ftype)
7192 
      iprot.readFieldEnd()
7193 
    iprot.readStructEnd()
7194 
 
7195 
  def write(self, oprot):
7196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7198 
      return
7199 
    oprot.writeStructBegin('getAllItems_result')
7200 
    if self.success is not None:
7201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7203 
      for iter52 in self.success:
7204 
        iter52.write(oprot)
5944 mandeep.dh 7205 
      oprot.writeListEnd()
7206 
      oprot.writeFieldEnd()
7207 
    if self.cex is not None:
7208 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7209 
      self.cex.write(oprot)
7210 
      oprot.writeFieldEnd()
7211 
    oprot.writeFieldStop()
7212 
    oprot.writeStructEnd()
7213 
 
7214 
  def validate(self):
7215 
    return
7216 
 
7217 
 
7218 
  def __repr__(self):
7219 
    L = ['%s=%r' % (key, value)
7220 
      for key, value in self.__dict__.iteritems()]
7221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7222 
 
7223 
  def __eq__(self, other):
7224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7225 
 
7226 
  def __ne__(self, other):
7227 
    return not (self == other)
7228 
 
7229 
class getAllItemsByStatus_args:
7230 
  """
7231 
  Attributes:
7232 
   - itemStatus
7233 
  """
7234 
 
7235 
  thrift_spec = (
7236 
    None, # 0
7237 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7238 
  )
7239 
 
7240 
  def __init__(self, itemStatus=None,):
7241 
    self.itemStatus = itemStatus
7242 
 
7243 
  def read(self, iprot):
7244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7246 
      return
7247 
    iprot.readStructBegin()
7248 
    while True:
7249 
      (fname, ftype, fid) = iprot.readFieldBegin()
7250 
      if ftype == TType.STOP:
7251 
        break
7252 
      if fid == 1:
7253 
        if ftype == TType.I32:
7254 
          self.itemStatus = iprot.readI32();
7255 
        else:
7256 
          iprot.skip(ftype)
7257 
      else:
7258 
        iprot.skip(ftype)
7259 
      iprot.readFieldEnd()
7260 
    iprot.readStructEnd()
7261 
 
7262 
  def write(self, oprot):
7263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7265 
      return
7266 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7267 
    if self.itemStatus is not None:
7268 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7269 
      oprot.writeI32(self.itemStatus)
7270 
      oprot.writeFieldEnd()
7271 
    oprot.writeFieldStop()
7272 
    oprot.writeStructEnd()
7273 
 
7274 
  def validate(self):
7275 
    return
7276 
 
7277 
 
7278 
  def __repr__(self):
7279 
    L = ['%s=%r' % (key, value)
7280 
      for key, value in self.__dict__.iteritems()]
7281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7282 
 
7283 
  def __eq__(self, other):
7284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7285 
 
7286 
  def __ne__(self, other):
7287 
    return not (self == other)
7288 
 
7289 
class getAllItemsByStatus_result:
7290 
  """
7291 
  Attributes:
7292 
   - success
7293 
   - cex
7294 
  """
7295 
 
7296 
  thrift_spec = (
7297 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7298 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7299 
  )
7300 
 
7301 
  def __init__(self, success=None, cex=None,):
7302 
    self.success = success
7303 
    self.cex = cex
7304 
 
7305 
  def read(self, iprot):
7306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7308 
      return
7309 
    iprot.readStructBegin()
7310 
    while True:
7311 
      (fname, ftype, fid) = iprot.readFieldBegin()
7312 
      if ftype == TType.STOP:
7313 
        break
7314 
      if fid == 0:
7315 
        if ftype == TType.LIST:
7316 
          self.success = []
7438 amit.gupta 7317 
          (_etype56, _size53) = iprot.readListBegin()
7318 
          for _i57 in xrange(_size53):
7319 
            _elem58 = Item()
7320 
            _elem58.read(iprot)
7321 
            self.success.append(_elem58)
5944 mandeep.dh 7322 
          iprot.readListEnd()
7323 
        else:
7324 
          iprot.skip(ftype)
7325 
      elif fid == 1:
7326 
        if ftype == TType.STRUCT:
7327 
          self.cex = CatalogServiceException()
7328 
          self.cex.read(iprot)
7329 
        else:
7330 
          iprot.skip(ftype)
7331 
      else:
7332 
        iprot.skip(ftype)
7333 
      iprot.readFieldEnd()
7334 
    iprot.readStructEnd()
7335 
 
7336 
  def write(self, oprot):
7337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7339 
      return
7340 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7341 
    if self.success is not None:
7342 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7343 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7344 
      for iter59 in self.success:
7345 
        iter59.write(oprot)
5944 mandeep.dh 7346 
      oprot.writeListEnd()
7347 
      oprot.writeFieldEnd()
7348 
    if self.cex is not None:
7349 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7350 
      self.cex.write(oprot)
7351 
      oprot.writeFieldEnd()
7352 
    oprot.writeFieldStop()
7353 
    oprot.writeStructEnd()
7354 
 
7355 
  def validate(self):
7356 
    return
7357 
 
7358 
 
7359 
  def __repr__(self):
7360 
    L = ['%s=%r' % (key, value)
7361 
      for key, value in self.__dict__.iteritems()]
7362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7363 
 
7364 
  def __eq__(self, other):
7365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7366 
 
7367 
  def __ne__(self, other):
7368 
    return not (self == other)
7369 
 
7370 
class markItemAsContentComplete_args:
7371 
  """
7372 
  Attributes:
7373 
   - entityId
7374 
   - category
7375 
   - brand
7376 
   - modelName
7377 
   - modelNumber
7378 
  """
7379 
 
7380 
  thrift_spec = (
7381 
    None, # 0
7382 
    (1, TType.I64, 'entityId', None, None, ), # 1
7383 
    (2, TType.I64, 'category', None, None, ), # 2
7384 
    (3, TType.STRING, 'brand', None, None, ), # 3
7385 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7386 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7387 
  )
7388 
 
7389 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7390 
    self.entityId = entityId
7391 
    self.category = category
7392 
    self.brand = brand
7393 
    self.modelName = modelName
7394 
    self.modelNumber = modelNumber
7395 
 
7396 
  def read(self, iprot):
7397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7399 
      return
7400 
    iprot.readStructBegin()
7401 
    while True:
7402 
      (fname, ftype, fid) = iprot.readFieldBegin()
7403 
      if ftype == TType.STOP:
7404 
        break
7405 
      if fid == 1:
7406 
        if ftype == TType.I64:
7407 
          self.entityId = iprot.readI64();
7408 
        else:
7409 
          iprot.skip(ftype)
7410 
      elif fid == 2:
7411 
        if ftype == TType.I64:
7412 
          self.category = iprot.readI64();
7413 
        else:
7414 
          iprot.skip(ftype)
7415 
      elif fid == 3:
7416 
        if ftype == TType.STRING:
7417 
          self.brand = iprot.readString();
7418 
        else:
7419 
          iprot.skip(ftype)
7420 
      elif fid == 4:
7421 
        if ftype == TType.STRING:
7422 
          self.modelName = iprot.readString();
7423 
        else:
7424 
          iprot.skip(ftype)
7425 
      elif fid == 5:
7426 
        if ftype == TType.STRING:
7427 
          self.modelNumber = iprot.readString();
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('markItemAsContentComplete_args')
7440 
    if self.entityId is not None:
7441 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7442 
      oprot.writeI64(self.entityId)
7443 
      oprot.writeFieldEnd()
7444 
    if self.category is not None:
7445 
      oprot.writeFieldBegin('category', TType.I64, 2)
7446 
      oprot.writeI64(self.category)
7447 
      oprot.writeFieldEnd()
7448 
    if self.brand is not None:
7449 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7450 
      oprot.writeString(self.brand)
7451 
      oprot.writeFieldEnd()
7452 
    if self.modelName is not None:
7453 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7454 
      oprot.writeString(self.modelName)
7455 
      oprot.writeFieldEnd()
7456 
    if self.modelNumber is not None:
7457 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7458 
      oprot.writeString(self.modelNumber)
7459 
      oprot.writeFieldEnd()
7460 
    oprot.writeFieldStop()
7461 
    oprot.writeStructEnd()
7462 
 
7463 
  def validate(self):
7464 
    return
7465 
 
7466 
 
7467 
  def __repr__(self):
7468 
    L = ['%s=%r' % (key, value)
7469 
      for key, value in self.__dict__.iteritems()]
7470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7471 
 
7472 
  def __eq__(self, other):
7473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7474 
 
7475 
  def __ne__(self, other):
7476 
    return not (self == other)
7477 
 
7478 
class markItemAsContentComplete_result:
7479 
  """
7480 
  Attributes:
7481 
   - success
7482 
   - cex
7483 
  """
7484 
 
7485 
  thrift_spec = (
7486 
    (0, TType.BOOL, 'success', None, None, ), # 0
7487 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7488 
  )
7489 
 
7490 
  def __init__(self, success=None, cex=None,):
7491 
    self.success = success
7492 
    self.cex = cex
7493 
 
7494 
  def read(self, iprot):
7495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7497 
      return
7498 
    iprot.readStructBegin()
7499 
    while True:
7500 
      (fname, ftype, fid) = iprot.readFieldBegin()
7501 
      if ftype == TType.STOP:
7502 
        break
7503 
      if fid == 0:
7504 
        if ftype == TType.BOOL:
7505 
          self.success = iprot.readBool();
7506 
        else:
7507 
          iprot.skip(ftype)
7508 
      elif fid == 1:
7509 
        if ftype == TType.STRUCT:
7510 
          self.cex = CatalogServiceException()
7511 
          self.cex.read(iprot)
7512 
        else:
7513 
          iprot.skip(ftype)
7514 
      else:
7515 
        iprot.skip(ftype)
7516 
      iprot.readFieldEnd()
7517 
    iprot.readStructEnd()
7518 
 
7519 
  def write(self, oprot):
7520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7522 
      return
7523 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7524 
    if self.success is not None:
7525 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7526 
      oprot.writeBool(self.success)
7527 
      oprot.writeFieldEnd()
7528 
    if self.cex is not None:
7529 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7530 
      self.cex.write(oprot)
7531 
      oprot.writeFieldEnd()
7532 
    oprot.writeFieldStop()
7533 
    oprot.writeStructEnd()
7534 
 
7535 
  def validate(self):
7536 
    return
7537 
 
7538 
 
7539 
  def __repr__(self):
7540 
    L = ['%s=%r' % (key, value)
7541 
      for key, value in self.__dict__.iteritems()]
7542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7543 
 
7544 
  def __eq__(self, other):
7545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7546 
 
7547 
  def __ne__(self, other):
7548 
    return not (self == other)
7549 
 
7550 
class getAllItemsInRange_args:
7551 
  """
7552 
  Attributes:
7553 
   - offset
7554 
   - limit
7555 
  """
7556 
 
7557 
  thrift_spec = (
7558 
    None, # 0
7559 
    (1, TType.I64, 'offset', None, None, ), # 1
7560 
    (2, TType.I64, 'limit', None, None, ), # 2
7561 
  )
7562 
 
7563 
  def __init__(self, offset=None, limit=None,):
7564 
    self.offset = offset
7565 
    self.limit = limit
7566 
 
7567 
  def read(self, iprot):
7568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7570 
      return
7571 
    iprot.readStructBegin()
7572 
    while True:
7573 
      (fname, ftype, fid) = iprot.readFieldBegin()
7574 
      if ftype == TType.STOP:
7575 
        break
7576 
      if fid == 1:
7577 
        if ftype == TType.I64:
7578 
          self.offset = iprot.readI64();
7579 
        else:
7580 
          iprot.skip(ftype)
7581 
      elif fid == 2:
7582 
        if ftype == TType.I64:
7583 
          self.limit = iprot.readI64();
7584 
        else:
7585 
          iprot.skip(ftype)
7586 
      else:
7587 
        iprot.skip(ftype)
7588 
      iprot.readFieldEnd()
7589 
    iprot.readStructEnd()
7590 
 
7591 
  def write(self, oprot):
7592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7594 
      return
7595 
    oprot.writeStructBegin('getAllItemsInRange_args')
7596 
    if self.offset is not None:
7597 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7598 
      oprot.writeI64(self.offset)
7599 
      oprot.writeFieldEnd()
7600 
    if self.limit is not None:
7601 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7602 
      oprot.writeI64(self.limit)
7603 
      oprot.writeFieldEnd()
7604 
    oprot.writeFieldStop()
7605 
    oprot.writeStructEnd()
7606 
 
7607 
  def validate(self):
7608 
    return
7609 
 
7610 
 
7611 
  def __repr__(self):
7612 
    L = ['%s=%r' % (key, value)
7613 
      for key, value in self.__dict__.iteritems()]
7614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7615 
 
7616 
  def __eq__(self, other):
7617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7618 
 
7619 
  def __ne__(self, other):
7620 
    return not (self == other)
7621 
 
7622 
class getAllItemsInRange_result:
7623 
  """
7624 
  Attributes:
7625 
   - success
7626 
   - cex
7627 
  """
7628 
 
7629 
  thrift_spec = (
7630 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7631 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7632 
  )
7633 
 
7634 
  def __init__(self, success=None, cex=None,):
7635 
    self.success = success
7636 
    self.cex = cex
7637 
 
7638 
  def read(self, iprot):
7639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7641 
      return
7642 
    iprot.readStructBegin()
7643 
    while True:
7644 
      (fname, ftype, fid) = iprot.readFieldBegin()
7645 
      if ftype == TType.STOP:
7646 
        break
7647 
      if fid == 0:
7648 
        if ftype == TType.LIST:
7649 
          self.success = []
7438 amit.gupta 7650 
          (_etype63, _size60) = iprot.readListBegin()
7651 
          for _i64 in xrange(_size60):
7652 
            _elem65 = Item()
7653 
            _elem65.read(iprot)
7654 
            self.success.append(_elem65)
5944 mandeep.dh 7655 
          iprot.readListEnd()
7656 
        else:
7657 
          iprot.skip(ftype)
7658 
      elif fid == 1:
7659 
        if ftype == TType.STRUCT:
7660 
          self.cex = CatalogServiceException()
7661 
          self.cex.read(iprot)
7662 
        else:
7663 
          iprot.skip(ftype)
7664 
      else:
7665 
        iprot.skip(ftype)
7666 
      iprot.readFieldEnd()
7667 
    iprot.readStructEnd()
7668 
 
7669 
  def write(self, oprot):
7670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7672 
      return
7673 
    oprot.writeStructBegin('getAllItemsInRange_result')
7674 
    if self.success is not None:
7675 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7676 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7677 
      for iter66 in self.success:
7678 
        iter66.write(oprot)
5944 mandeep.dh 7679 
      oprot.writeListEnd()
7680 
      oprot.writeFieldEnd()
7681 
    if self.cex is not None:
7682 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7683 
      self.cex.write(oprot)
7684 
      oprot.writeFieldEnd()
7685 
    oprot.writeFieldStop()
7686 
    oprot.writeStructEnd()
7687 
 
7688 
  def validate(self):
7689 
    return
7690 
 
7691 
 
7692 
  def __repr__(self):
7693 
    L = ['%s=%r' % (key, value)
7694 
      for key, value in self.__dict__.iteritems()]
7695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7696 
 
7697 
  def __eq__(self, other):
7698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7699 
 
7700 
  def __ne__(self, other):
7701 
    return not (self == other)
7702 
 
7703 
class getAllItemsByStatusInRange_args:
7704 
  """
7705 
  Attributes:
7706 
   - itemStatus
7707 
   - offset
7708 
   - limit
7709 
  """
7710 
 
7711 
  thrift_spec = (
7712 
    None, # 0
7713 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7714 
    (2, TType.I64, 'offset', None, None, ), # 2
7715 
    (3, TType.I64, 'limit', None, None, ), # 3
7716 
  )
7717 
 
7718 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7719 
    self.itemStatus = itemStatus
7720 
    self.offset = offset
7721 
    self.limit = limit
7722 
 
7723 
  def read(self, iprot):
7724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7726 
      return
7727 
    iprot.readStructBegin()
7728 
    while True:
7729 
      (fname, ftype, fid) = iprot.readFieldBegin()
7730 
      if ftype == TType.STOP:
7731 
        break
7732 
      if fid == 1:
7733 
        if ftype == TType.I32:
7734 
          self.itemStatus = iprot.readI32();
7735 
        else:
7736 
          iprot.skip(ftype)
7737 
      elif fid == 2:
7738 
        if ftype == TType.I64:
7739 
          self.offset = iprot.readI64();
7740 
        else:
7741 
          iprot.skip(ftype)
7742 
      elif fid == 3:
7743 
        if ftype == TType.I64:
7744 
          self.limit = iprot.readI64();
7745 
        else:
7746 
          iprot.skip(ftype)
7747 
      else:
7748 
        iprot.skip(ftype)
7749 
      iprot.readFieldEnd()
7750 
    iprot.readStructEnd()
7751 
 
7752 
  def write(self, oprot):
7753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7755 
      return
7756 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7757 
    if self.itemStatus is not None:
7758 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7759 
      oprot.writeI32(self.itemStatus)
7760 
      oprot.writeFieldEnd()
7761 
    if self.offset is not None:
7762 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7763 
      oprot.writeI64(self.offset)
7764 
      oprot.writeFieldEnd()
7765 
    if self.limit is not None:
7766 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7767 
      oprot.writeI64(self.limit)
7768 
      oprot.writeFieldEnd()
7769 
    oprot.writeFieldStop()
7770 
    oprot.writeStructEnd()
7771 
 
7772 
  def validate(self):
7773 
    return
7774 
 
7775 
 
7776 
  def __repr__(self):
7777 
    L = ['%s=%r' % (key, value)
7778 
      for key, value in self.__dict__.iteritems()]
7779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7780 
 
7781 
  def __eq__(self, other):
7782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7783 
 
7784 
  def __ne__(self, other):
7785 
    return not (self == other)
7786 
 
7787 
class getAllItemsByStatusInRange_result:
7788 
  """
7789 
  Attributes:
7790 
   - success
7791 
   - cex
7792 
  """
7793 
 
7794 
  thrift_spec = (
7795 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7796 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7797 
  )
7798 
 
7799 
  def __init__(self, success=None, cex=None,):
7800 
    self.success = success
7801 
    self.cex = cex
7802 
 
7803 
  def read(self, iprot):
7804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7806 
      return
7807 
    iprot.readStructBegin()
7808 
    while True:
7809 
      (fname, ftype, fid) = iprot.readFieldBegin()
7810 
      if ftype == TType.STOP:
7811 
        break
7812 
      if fid == 0:
7813 
        if ftype == TType.LIST:
7814 
          self.success = []
7438 amit.gupta 7815 
          (_etype70, _size67) = iprot.readListBegin()
7816 
          for _i71 in xrange(_size67):
7817 
            _elem72 = Item()
7818 
            _elem72.read(iprot)
7819 
            self.success.append(_elem72)
5944 mandeep.dh 7820 
          iprot.readListEnd()
7821 
        else:
7822 
          iprot.skip(ftype)
7823 
      elif fid == 1:
7824 
        if ftype == TType.STRUCT:
7825 
          self.cex = CatalogServiceException()
7826 
          self.cex.read(iprot)
7827 
        else:
7828 
          iprot.skip(ftype)
7829 
      else:
7830 
        iprot.skip(ftype)
7831 
      iprot.readFieldEnd()
7832 
    iprot.readStructEnd()
7833 
 
7834 
  def write(self, oprot):
7835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7837 
      return
7838 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7839 
    if self.success is not None:
7840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7842 
      for iter73 in self.success:
7843 
        iter73.write(oprot)
5944 mandeep.dh 7844 
      oprot.writeListEnd()
7845 
      oprot.writeFieldEnd()
7846 
    if self.cex is not None:
7847 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7848 
      self.cex.write(oprot)
7849 
      oprot.writeFieldEnd()
7850 
    oprot.writeFieldStop()
7851 
    oprot.writeStructEnd()
7852 
 
7853 
  def validate(self):
7854 
    return
7855 
 
7856 
 
7857 
  def __repr__(self):
7858 
    L = ['%s=%r' % (key, value)
7859 
      for key, value in self.__dict__.iteritems()]
7860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7861 
 
7862 
  def __eq__(self, other):
7863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7864 
 
7865 
  def __ne__(self, other):
7866 
    return not (self == other)
7867 
 
7868 
class getItemCountByStatus_args:
7869 
  """
7870 
  Attributes:
7871 
   - useStatus
7872 
   - itemStatus
7873 
  """
7874 
 
7875 
  thrift_spec = (
7876 
    None, # 0
7877 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7878 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7879 
  )
7880 
 
7881 
  def __init__(self, useStatus=None, itemStatus=None,):
7882 
    self.useStatus = useStatus
7883 
    self.itemStatus = itemStatus
7884 
 
7885 
  def read(self, iprot):
7886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7888 
      return
7889 
    iprot.readStructBegin()
7890 
    while True:
7891 
      (fname, ftype, fid) = iprot.readFieldBegin()
7892 
      if ftype == TType.STOP:
7893 
        break
7894 
      if fid == 1:
7895 
        if ftype == TType.BOOL:
7896 
          self.useStatus = iprot.readBool();
7897 
        else:
7898 
          iprot.skip(ftype)
7899 
      elif fid == 2:
7900 
        if ftype == TType.I32:
7901 
          self.itemStatus = iprot.readI32();
7902 
        else:
7903 
          iprot.skip(ftype)
7904 
      else:
7905 
        iprot.skip(ftype)
7906 
      iprot.readFieldEnd()
7907 
    iprot.readStructEnd()
7908 
 
7909 
  def write(self, oprot):
7910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7912 
      return
7913 
    oprot.writeStructBegin('getItemCountByStatus_args')
7914 
    if self.useStatus is not None:
7915 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7916 
      oprot.writeBool(self.useStatus)
7917 
      oprot.writeFieldEnd()
7918 
    if self.itemStatus is not None:
7919 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7920 
      oprot.writeI32(self.itemStatus)
7921 
      oprot.writeFieldEnd()
7922 
    oprot.writeFieldStop()
7923 
    oprot.writeStructEnd()
7924 
 
7925 
  def validate(self):
7926 
    return
7927 
 
7928 
 
7929 
  def __repr__(self):
7930 
    L = ['%s=%r' % (key, value)
7931 
      for key, value in self.__dict__.iteritems()]
7932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7933 
 
7934 
  def __eq__(self, other):
7935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7936 
 
7937 
  def __ne__(self, other):
7938 
    return not (self == other)
7939 
 
7940 
class getItemCountByStatus_result:
7941 
  """
7942 
  Attributes:
7943 
   - success
7944 
  """
7945 
 
7946 
  thrift_spec = (
7947 
    (0, TType.I32, 'success', None, None, ), # 0
7948 
  )
7949 
 
7950 
  def __init__(self, success=None,):
7951 
    self.success = success
7952 
 
7953 
  def read(self, iprot):
7954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7956 
      return
7957 
    iprot.readStructBegin()
7958 
    while True:
7959 
      (fname, ftype, fid) = iprot.readFieldBegin()
7960 
      if ftype == TType.STOP:
7961 
        break
7962 
      if fid == 0:
7963 
        if ftype == TType.I32:
7964 
          self.success = iprot.readI32();
7965 
        else:
7966 
          iprot.skip(ftype)
7967 
      else:
7968 
        iprot.skip(ftype)
7969 
      iprot.readFieldEnd()
7970 
    iprot.readStructEnd()
7971 
 
7972 
  def write(self, oprot):
7973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7975 
      return
7976 
    oprot.writeStructBegin('getItemCountByStatus_result')
7977 
    if self.success is not None:
7978 
      oprot.writeFieldBegin('success', TType.I32, 0)
7979 
      oprot.writeI32(self.success)
7980 
      oprot.writeFieldEnd()
7981 
    oprot.writeFieldStop()
7982 
    oprot.writeStructEnd()
7983 
 
7984 
  def validate(self):
7985 
    return
7986 
 
7987 
 
7988 
  def __repr__(self):
7989 
    L = ['%s=%r' % (key, value)
7990 
      for key, value in self.__dict__.iteritems()]
7991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7992 
 
7993 
  def __eq__(self, other):
7994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7995 
 
7996 
  def __ne__(self, other):
7997 
    return not (self == other)
7998 
 
7999 
class getBestSellers_args:
8000 
 
8001 
  thrift_spec = (
8002 
  )
8003 
 
8004 
  def read(self, iprot):
8005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8007 
      return
8008 
    iprot.readStructBegin()
8009 
    while True:
8010 
      (fname, ftype, fid) = iprot.readFieldBegin()
8011 
      if ftype == TType.STOP:
8012 
        break
8013 
      else:
8014 
        iprot.skip(ftype)
8015 
      iprot.readFieldEnd()
8016 
    iprot.readStructEnd()
8017 
 
8018 
  def write(self, oprot):
8019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8021 
      return
8022 
    oprot.writeStructBegin('getBestSellers_args')
8023 
    oprot.writeFieldStop()
8024 
    oprot.writeStructEnd()
8025 
 
8026 
  def validate(self):
8027 
    return
8028 
 
8029 
 
8030 
  def __repr__(self):
8031 
    L = ['%s=%r' % (key, value)
8032 
      for key, value in self.__dict__.iteritems()]
8033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8034 
 
8035 
  def __eq__(self, other):
8036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8037 
 
8038 
  def __ne__(self, other):
8039 
    return not (self == other)
8040 
 
8041 
class getBestSellers_result:
8042 
  """
8043 
  Attributes:
8044 
   - success
8045 
   - isex
8046 
  """
8047 
 
8048 
  thrift_spec = (
8049 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8050 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8051 
  )
8052 
 
8053 
  def __init__(self, success=None, isex=None,):
8054 
    self.success = success
8055 
    self.isex = isex
8056 
 
8057 
  def read(self, iprot):
8058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8060 
      return
8061 
    iprot.readStructBegin()
8062 
    while True:
8063 
      (fname, ftype, fid) = iprot.readFieldBegin()
8064 
      if ftype == TType.STOP:
8065 
        break
8066 
      if fid == 0:
8067 
        if ftype == TType.LIST:
8068 
          self.success = []
7438 amit.gupta 8069 
          (_etype77, _size74) = iprot.readListBegin()
8070 
          for _i78 in xrange(_size74):
8071 
            _elem79 = Item()
8072 
            _elem79.read(iprot)
8073 
            self.success.append(_elem79)
5944 mandeep.dh 8074 
          iprot.readListEnd()
8075 
        else:
8076 
          iprot.skip(ftype)
8077 
      elif fid == 1:
8078 
        if ftype == TType.STRUCT:
8079 
          self.isex = CatalogServiceException()
8080 
          self.isex.read(iprot)
8081 
        else:
8082 
          iprot.skip(ftype)
8083 
      else:
8084 
        iprot.skip(ftype)
8085 
      iprot.readFieldEnd()
8086 
    iprot.readStructEnd()
8087 
 
8088 
  def write(self, oprot):
8089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8091 
      return
8092 
    oprot.writeStructBegin('getBestSellers_result')
8093 
    if self.success is not None:
8094 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8095 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8096 
      for iter80 in self.success:
8097 
        iter80.write(oprot)
5944 mandeep.dh 8098 
      oprot.writeListEnd()
8099 
      oprot.writeFieldEnd()
8100 
    if self.isex is not None:
8101 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8102 
      self.isex.write(oprot)
8103 
      oprot.writeFieldEnd()
8104 
    oprot.writeFieldStop()
8105 
    oprot.writeStructEnd()
8106 
 
8107 
  def validate(self):
8108 
    return
8109 
 
8110 
 
8111 
  def __repr__(self):
8112 
    L = ['%s=%r' % (key, value)
8113 
      for key, value in self.__dict__.iteritems()]
8114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8115 
 
8116 
  def __eq__(self, other):
8117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8118 
 
8119 
  def __ne__(self, other):
8120 
    return not (self == other)
8121 
 
8122 
class getBestSellersCatalogIds_args:
8123 
  """
8124 
  Attributes:
8125 
   - beginIndex
8126 
   - totalItems
8127 
   - brand
8128 
   - category
8129 
  """
8130 
 
8131 
  thrift_spec = (
8132 
    None, # 0
8133 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8134 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8135 
    (3, TType.STRING, 'brand', None, None, ), # 3
8136 
    (4, TType.I64, 'category', None, None, ), # 4
8137 
  )
8138 
 
8139 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8140 
    self.beginIndex = beginIndex
8141 
    self.totalItems = totalItems
8142 
    self.brand = brand
8143 
    self.category = category
8144 
 
8145 
  def read(self, iprot):
8146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8148 
      return
8149 
    iprot.readStructBegin()
8150 
    while True:
8151 
      (fname, ftype, fid) = iprot.readFieldBegin()
8152 
      if ftype == TType.STOP:
8153 
        break
8154 
      if fid == 1:
8155 
        if ftype == TType.I64:
8156 
          self.beginIndex = iprot.readI64();
8157 
        else:
8158 
          iprot.skip(ftype)
8159 
      elif fid == 2:
8160 
        if ftype == TType.I64:
8161 
          self.totalItems = iprot.readI64();
8162 
        else:
8163 
          iprot.skip(ftype)
8164 
      elif fid == 3:
8165 
        if ftype == TType.STRING:
8166 
          self.brand = iprot.readString();
8167 
        else:
8168 
          iprot.skip(ftype)
8169 
      elif fid == 4:
8170 
        if ftype == TType.I64:
8171 
          self.category = iprot.readI64();
8172 
        else:
8173 
          iprot.skip(ftype)
8174 
      else:
8175 
        iprot.skip(ftype)
8176 
      iprot.readFieldEnd()
8177 
    iprot.readStructEnd()
8178 
 
8179 
  def write(self, oprot):
8180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8182 
      return
8183 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8184 
    if self.beginIndex is not None:
8185 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8186 
      oprot.writeI64(self.beginIndex)
8187 
      oprot.writeFieldEnd()
8188 
    if self.totalItems is not None:
8189 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8190 
      oprot.writeI64(self.totalItems)
8191 
      oprot.writeFieldEnd()
8192 
    if self.brand is not None:
8193 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8194 
      oprot.writeString(self.brand)
8195 
      oprot.writeFieldEnd()
8196 
    if self.category is not None:
8197 
      oprot.writeFieldBegin('category', TType.I64, 4)
8198 
      oprot.writeI64(self.category)
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 getBestSellersCatalogIds_result:
8219 
  """
8220 
  Attributes:
8221 
   - success
8222 
   - cex
8223 
  """
8224 
 
8225 
  thrift_spec = (
8226 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8227 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8228 
  )
8229 
 
8230 
  def __init__(self, success=None, cex=None,):
8231 
    self.success = success
8232 
    self.cex = cex
8233 
 
8234 
  def read(self, iprot):
8235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8237 
      return
8238 
    iprot.readStructBegin()
8239 
    while True:
8240 
      (fname, ftype, fid) = iprot.readFieldBegin()
8241 
      if ftype == TType.STOP:
8242 
        break
8243 
      if fid == 0:
8244 
        if ftype == TType.LIST:
8245 
          self.success = []
7438 amit.gupta 8246 
          (_etype84, _size81) = iprot.readListBegin()
8247 
          for _i85 in xrange(_size81):
8248 
            _elem86 = iprot.readI64();
8249 
            self.success.append(_elem86)
5944 mandeep.dh 8250 
          iprot.readListEnd()
8251 
        else:
8252 
          iprot.skip(ftype)
8253 
      elif fid == 1:
8254 
        if ftype == TType.STRUCT:
8255 
          self.cex = CatalogServiceException()
8256 
          self.cex.read(iprot)
8257 
        else:
8258 
          iprot.skip(ftype)
8259 
      else:
8260 
        iprot.skip(ftype)
8261 
      iprot.readFieldEnd()
8262 
    iprot.readStructEnd()
8263 
 
8264 
  def write(self, oprot):
8265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8267 
      return
8268 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8269 
    if self.success is not None:
8270 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8271 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8272 
      for iter87 in self.success:
8273 
        oprot.writeI64(iter87)
5944 mandeep.dh 8274 
      oprot.writeListEnd()
8275 
      oprot.writeFieldEnd()
8276 
    if self.cex is not None:
8277 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8278 
      self.cex.write(oprot)
8279 
      oprot.writeFieldEnd()
8280 
    oprot.writeFieldStop()
8281 
    oprot.writeStructEnd()
8282 
 
8283 
  def validate(self):
8284 
    return
8285 
 
8286 
 
8287 
  def __repr__(self):
8288 
    L = ['%s=%r' % (key, value)
8289 
      for key, value in self.__dict__.iteritems()]
8290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8291 
 
8292 
  def __eq__(self, other):
8293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8294 
 
8295 
  def __ne__(self, other):
8296 
    return not (self == other)
8297 
 
8298 
class getBestSellersCount_args:
8299 
 
8300 
  thrift_spec = (
8301 
  )
8302 
 
8303 
  def read(self, iprot):
8304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8306 
      return
8307 
    iprot.readStructBegin()
8308 
    while True:
8309 
      (fname, ftype, fid) = iprot.readFieldBegin()
8310 
      if ftype == TType.STOP:
8311 
        break
8312 
      else:
8313 
        iprot.skip(ftype)
8314 
      iprot.readFieldEnd()
8315 
    iprot.readStructEnd()
8316 
 
8317 
  def write(self, oprot):
8318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8320 
      return
8321 
    oprot.writeStructBegin('getBestSellersCount_args')
8322 
    oprot.writeFieldStop()
8323 
    oprot.writeStructEnd()
8324 
 
8325 
  def validate(self):
8326 
    return
8327 
 
8328 
 
8329 
  def __repr__(self):
8330 
    L = ['%s=%r' % (key, value)
8331 
      for key, value in self.__dict__.iteritems()]
8332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8333 
 
8334 
  def __eq__(self, other):
8335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8336 
 
8337 
  def __ne__(self, other):
8338 
    return not (self == other)
8339 
 
8340 
class getBestSellersCount_result:
8341 
  """
8342 
  Attributes:
8343 
   - success
8344 
   - cex
8345 
  """
8346 
 
8347 
  thrift_spec = (
8348 
    (0, TType.I64, 'success', None, None, ), # 0
8349 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8350 
  )
8351 
 
8352 
  def __init__(self, success=None, cex=None,):
8353 
    self.success = success
8354 
    self.cex = cex
8355 
 
8356 
  def read(self, iprot):
8357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8359 
      return
8360 
    iprot.readStructBegin()
8361 
    while True:
8362 
      (fname, ftype, fid) = iprot.readFieldBegin()
8363 
      if ftype == TType.STOP:
8364 
        break
8365 
      if fid == 0:
8366 
        if ftype == TType.I64:
8367 
          self.success = iprot.readI64();
8368 
        else:
8369 
          iprot.skip(ftype)
8370 
      elif fid == 1:
8371 
        if ftype == TType.STRUCT:
8372 
          self.cex = CatalogServiceException()
8373 
          self.cex.read(iprot)
8374 
        else:
8375 
          iprot.skip(ftype)
8376 
      else:
8377 
        iprot.skip(ftype)
8378 
      iprot.readFieldEnd()
8379 
    iprot.readStructEnd()
8380 
 
8381 
  def write(self, oprot):
8382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8384 
      return
8385 
    oprot.writeStructBegin('getBestSellersCount_result')
8386 
    if self.success is not None:
8387 
      oprot.writeFieldBegin('success', TType.I64, 0)
8388 
      oprot.writeI64(self.success)
8389 
      oprot.writeFieldEnd()
8390 
    if self.cex is not None:
8391 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8392 
      self.cex.write(oprot)
8393 
      oprot.writeFieldEnd()
8394 
    oprot.writeFieldStop()
8395 
    oprot.writeStructEnd()
8396 
 
8397 
  def validate(self):
8398 
    return
8399 
 
8400 
 
8401 
  def __repr__(self):
8402 
    L = ['%s=%r' % (key, value)
8403 
      for key, value in self.__dict__.iteritems()]
8404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8405 
 
8406 
  def __eq__(self, other):
8407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8408 
 
8409 
  def __ne__(self, other):
8410 
    return not (self == other)
8411 
 
8412 
class getBestDeals_args:
8413 
 
8414 
  thrift_spec = (
8415 
  )
8416 
 
8417 
  def read(self, iprot):
8418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8420 
      return
8421 
    iprot.readStructBegin()
8422 
    while True:
8423 
      (fname, ftype, fid) = iprot.readFieldBegin()
8424 
      if ftype == TType.STOP:
8425 
        break
8426 
      else:
8427 
        iprot.skip(ftype)
8428 
      iprot.readFieldEnd()
8429 
    iprot.readStructEnd()
8430 
 
8431 
  def write(self, oprot):
8432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8434 
      return
8435 
    oprot.writeStructBegin('getBestDeals_args')
8436 
    oprot.writeFieldStop()
8437 
    oprot.writeStructEnd()
8438 
 
8439 
  def validate(self):
8440 
    return
8441 
 
8442 
 
8443 
  def __repr__(self):
8444 
    L = ['%s=%r' % (key, value)
8445 
      for key, value in self.__dict__.iteritems()]
8446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8447 
 
8448 
  def __eq__(self, other):
8449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8450 
 
8451 
  def __ne__(self, other):
8452 
    return not (self == other)
8453 
 
8454 
class getBestDeals_result:
8455 
  """
8456 
  Attributes:
8457 
   - success
8458 
   - isex
8459 
  """
8460 
 
8461 
  thrift_spec = (
8462 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8463 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8464 
  )
8465 
 
8466 
  def __init__(self, success=None, isex=None,):
8467 
    self.success = success
8468 
    self.isex = isex
8469 
 
8470 
  def read(self, iprot):
8471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8473 
      return
8474 
    iprot.readStructBegin()
8475 
    while True:
8476 
      (fname, ftype, fid) = iprot.readFieldBegin()
8477 
      if ftype == TType.STOP:
8478 
        break
8479 
      if fid == 0:
8480 
        if ftype == TType.LIST:
8481 
          self.success = []
7438 amit.gupta 8482 
          (_etype91, _size88) = iprot.readListBegin()
8483 
          for _i92 in xrange(_size88):
8484 
            _elem93 = Item()
8485 
            _elem93.read(iprot)
8486 
            self.success.append(_elem93)
5944 mandeep.dh 8487 
          iprot.readListEnd()
8488 
        else:
8489 
          iprot.skip(ftype)
8490 
      elif fid == 1:
8491 
        if ftype == TType.STRUCT:
8492 
          self.isex = CatalogServiceException()
8493 
          self.isex.read(iprot)
8494 
        else:
8495 
          iprot.skip(ftype)
8496 
      else:
8497 
        iprot.skip(ftype)
8498 
      iprot.readFieldEnd()
8499 
    iprot.readStructEnd()
8500 
 
8501 
  def write(self, oprot):
8502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8504 
      return
8505 
    oprot.writeStructBegin('getBestDeals_result')
8506 
    if self.success is not None:
8507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8509 
      for iter94 in self.success:
8510 
        iter94.write(oprot)
5944 mandeep.dh 8511 
      oprot.writeListEnd()
8512 
      oprot.writeFieldEnd()
8513 
    if self.isex is not None:
8514 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8515 
      self.isex.write(oprot)
8516 
      oprot.writeFieldEnd()
8517 
    oprot.writeFieldStop()
8518 
    oprot.writeStructEnd()
8519 
 
8520 
  def validate(self):
8521 
    return
8522 
 
8523 
 
8524 
  def __repr__(self):
8525 
    L = ['%s=%r' % (key, value)
8526 
      for key, value in self.__dict__.iteritems()]
8527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8528 
 
8529 
  def __eq__(self, other):
8530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8531 
 
8532 
  def __ne__(self, other):
8533 
    return not (self == other)
8534 
 
8535 
class getBestDealsCatalogIds_args:
8536 
  """
8537 
  Attributes:
8538 
   - beginIndex
8539 
   - totalItems
8540 
   - brand
8541 
   - category
8542 
  """
8543 
 
8544 
  thrift_spec = (
8545 
    None, # 0
8546 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8547 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8548 
    (3, TType.STRING, 'brand', None, None, ), # 3
8549 
    (4, TType.I64, 'category', None, None, ), # 4
8550 
  )
8551 
 
8552 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8553 
    self.beginIndex = beginIndex
8554 
    self.totalItems = totalItems
8555 
    self.brand = brand
8556 
    self.category = category
8557 
 
8558 
  def read(self, iprot):
8559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8561 
      return
8562 
    iprot.readStructBegin()
8563 
    while True:
8564 
      (fname, ftype, fid) = iprot.readFieldBegin()
8565 
      if ftype == TType.STOP:
8566 
        break
8567 
      if fid == 1:
8568 
        if ftype == TType.I64:
8569 
          self.beginIndex = iprot.readI64();
8570 
        else:
8571 
          iprot.skip(ftype)
8572 
      elif fid == 2:
8573 
        if ftype == TType.I64:
8574 
          self.totalItems = iprot.readI64();
8575 
        else:
8576 
          iprot.skip(ftype)
8577 
      elif fid == 3:
8578 
        if ftype == TType.STRING:
8579 
          self.brand = iprot.readString();
8580 
        else:
8581 
          iprot.skip(ftype)
8582 
      elif fid == 4:
8583 
        if ftype == TType.I64:
8584 
          self.category = iprot.readI64();
8585 
        else:
8586 
          iprot.skip(ftype)
8587 
      else:
8588 
        iprot.skip(ftype)
8589 
      iprot.readFieldEnd()
8590 
    iprot.readStructEnd()
8591 
 
8592 
  def write(self, oprot):
8593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8595 
      return
8596 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8597 
    if self.beginIndex is not None:
8598 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8599 
      oprot.writeI64(self.beginIndex)
8600 
      oprot.writeFieldEnd()
8601 
    if self.totalItems is not None:
8602 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8603 
      oprot.writeI64(self.totalItems)
8604 
      oprot.writeFieldEnd()
8605 
    if self.brand is not None:
8606 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8607 
      oprot.writeString(self.brand)
8608 
      oprot.writeFieldEnd()
8609 
    if self.category is not None:
8610 
      oprot.writeFieldBegin('category', TType.I64, 4)
8611 
      oprot.writeI64(self.category)
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 getBestDealsCatalogIds_result:
8632 
  """
8633 
  Attributes:
8634 
   - success
8635 
   - cex
8636 
  """
8637 
 
8638 
  thrift_spec = (
8639 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8640 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8641 
  )
8642 
 
8643 
  def __init__(self, success=None, cex=None,):
8644 
    self.success = success
8645 
    self.cex = cex
8646 
 
8647 
  def read(self, iprot):
8648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8650 
      return
8651 
    iprot.readStructBegin()
8652 
    while True:
8653 
      (fname, ftype, fid) = iprot.readFieldBegin()
8654 
      if ftype == TType.STOP:
8655 
        break
8656 
      if fid == 0:
8657 
        if ftype == TType.LIST:
8658 
          self.success = []
7438 amit.gupta 8659 
          (_etype98, _size95) = iprot.readListBegin()
8660 
          for _i99 in xrange(_size95):
8661 
            _elem100 = iprot.readI64();
8662 
            self.success.append(_elem100)
5944 mandeep.dh 8663 
          iprot.readListEnd()
8664 
        else:
8665 
          iprot.skip(ftype)
8666 
      elif fid == 1:
8667 
        if ftype == TType.STRUCT:
8668 
          self.cex = CatalogServiceException()
8669 
          self.cex.read(iprot)
8670 
        else:
8671 
          iprot.skip(ftype)
8672 
      else:
8673 
        iprot.skip(ftype)
8674 
      iprot.readFieldEnd()
8675 
    iprot.readStructEnd()
8676 
 
8677 
  def write(self, oprot):
8678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8680 
      return
8681 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8682 
    if self.success is not None:
8683 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8684 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8685 
      for iter101 in self.success:
8686 
        oprot.writeI64(iter101)
5944 mandeep.dh 8687 
      oprot.writeListEnd()
8688 
      oprot.writeFieldEnd()
8689 
    if self.cex is not None:
8690 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8691 
      self.cex.write(oprot)
8692 
      oprot.writeFieldEnd()
8693 
    oprot.writeFieldStop()
8694 
    oprot.writeStructEnd()
8695 
 
8696 
  def validate(self):
8697 
    return
8698 
 
8699 
 
8700 
  def __repr__(self):
8701 
    L = ['%s=%r' % (key, value)
8702 
      for key, value in self.__dict__.iteritems()]
8703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8704 
 
8705 
  def __eq__(self, other):
8706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8707 
 
8708 
  def __ne__(self, other):
8709 
    return not (self == other)
8710 
 
8711 
class getBestDealsCount_args:
8712 
 
8713 
  thrift_spec = (
8714 
  )
8715 
 
8716 
  def read(self, iprot):
8717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8719 
      return
8720 
    iprot.readStructBegin()
8721 
    while True:
8722 
      (fname, ftype, fid) = iprot.readFieldBegin()
8723 
      if ftype == TType.STOP:
8724 
        break
8725 
      else:
8726 
        iprot.skip(ftype)
8727 
      iprot.readFieldEnd()
8728 
    iprot.readStructEnd()
8729 
 
8730 
  def write(self, oprot):
8731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8733 
      return
8734 
    oprot.writeStructBegin('getBestDealsCount_args')
8735 
    oprot.writeFieldStop()
8736 
    oprot.writeStructEnd()
8737 
 
8738 
  def validate(self):
8739 
    return
8740 
 
8741 
 
8742 
  def __repr__(self):
8743 
    L = ['%s=%r' % (key, value)
8744 
      for key, value in self.__dict__.iteritems()]
8745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8746 
 
8747 
  def __eq__(self, other):
8748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8749 
 
8750 
  def __ne__(self, other):
8751 
    return not (self == other)
8752 
 
8753 
class getBestDealsCount_result:
8754 
  """
8755 
  Attributes:
8756 
   - success
8757 
   - cex
8758 
  """
8759 
 
8760 
  thrift_spec = (
8761 
    (0, TType.I64, 'success', None, None, ), # 0
8762 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8763 
  )
8764 
 
8765 
  def __init__(self, success=None, cex=None,):
8766 
    self.success = success
8767 
    self.cex = cex
8768 
 
8769 
  def read(self, iprot):
8770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8772 
      return
8773 
    iprot.readStructBegin()
8774 
    while True:
8775 
      (fname, ftype, fid) = iprot.readFieldBegin()
8776 
      if ftype == TType.STOP:
8777 
        break
8778 
      if fid == 0:
8779 
        if ftype == TType.I64:
8780 
          self.success = iprot.readI64();
8781 
        else:
8782 
          iprot.skip(ftype)
8783 
      elif fid == 1:
8784 
        if ftype == TType.STRUCT:
8785 
          self.cex = CatalogServiceException()
8786 
          self.cex.read(iprot)
8787 
        else:
8788 
          iprot.skip(ftype)
8789 
      else:
8790 
        iprot.skip(ftype)
8791 
      iprot.readFieldEnd()
8792 
    iprot.readStructEnd()
8793 
 
8794 
  def write(self, oprot):
8795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8797 
      return
8798 
    oprot.writeStructBegin('getBestDealsCount_result')
8799 
    if self.success is not None:
8800 
      oprot.writeFieldBegin('success', TType.I64, 0)
8801 
      oprot.writeI64(self.success)
8802 
      oprot.writeFieldEnd()
8803 
    if self.cex is not None:
8804 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8805 
      self.cex.write(oprot)
8806 
      oprot.writeFieldEnd()
8807 
    oprot.writeFieldStop()
8808 
    oprot.writeStructEnd()
8809 
 
8810 
  def validate(self):
8811 
    return
8812 
 
8813 
 
8814 
  def __repr__(self):
8815 
    L = ['%s=%r' % (key, value)
8816 
      for key, value in self.__dict__.iteritems()]
8817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8818 
 
8819 
  def __eq__(self, other):
8820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8821 
 
8822 
  def __ne__(self, other):
8823 
    return not (self == other)
8824 
 
8825 
class getComingSoon_args:
8826 
 
8827 
  thrift_spec = (
8828 
  )
8829 
 
8830 
  def read(self, iprot):
8831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8833 
      return
8834 
    iprot.readStructBegin()
8835 
    while True:
8836 
      (fname, ftype, fid) = iprot.readFieldBegin()
8837 
      if ftype == TType.STOP:
8838 
        break
8839 
      else:
8840 
        iprot.skip(ftype)
8841 
      iprot.readFieldEnd()
8842 
    iprot.readStructEnd()
8843 
 
8844 
  def write(self, oprot):
8845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8847 
      return
8848 
    oprot.writeStructBegin('getComingSoon_args')
8849 
    oprot.writeFieldStop()
8850 
    oprot.writeStructEnd()
8851 
 
8852 
  def validate(self):
8853 
    return
8854 
 
8855 
 
8856 
  def __repr__(self):
8857 
    L = ['%s=%r' % (key, value)
8858 
      for key, value in self.__dict__.iteritems()]
8859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8860 
 
8861 
  def __eq__(self, other):
8862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8863 
 
8864 
  def __ne__(self, other):
8865 
    return not (self == other)
8866 
 
8867 
class getComingSoon_result:
8868 
  """
8869 
  Attributes:
8870 
   - success
8871 
   - isex
8872 
  """
8873 
 
8874 
  thrift_spec = (
8875 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8876 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8877 
  )
8878 
 
8879 
  def __init__(self, success=None, isex=None,):
8880 
    self.success = success
8881 
    self.isex = isex
8882 
 
8883 
  def read(self, iprot):
8884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8886 
      return
8887 
    iprot.readStructBegin()
8888 
    while True:
8889 
      (fname, ftype, fid) = iprot.readFieldBegin()
8890 
      if ftype == TType.STOP:
8891 
        break
8892 
      if fid == 0:
8893 
        if ftype == TType.LIST:
8894 
          self.success = []
7438 amit.gupta 8895 
          (_etype105, _size102) = iprot.readListBegin()
8896 
          for _i106 in xrange(_size102):
8897 
            _elem107 = Item()
8898 
            _elem107.read(iprot)
8899 
            self.success.append(_elem107)
5944 mandeep.dh 8900 
          iprot.readListEnd()
8901 
        else:
8902 
          iprot.skip(ftype)
8903 
      elif fid == 1:
8904 
        if ftype == TType.STRUCT:
8905 
          self.isex = CatalogServiceException()
8906 
          self.isex.read(iprot)
8907 
        else:
8908 
          iprot.skip(ftype)
8909 
      else:
8910 
        iprot.skip(ftype)
8911 
      iprot.readFieldEnd()
8912 
    iprot.readStructEnd()
8913 
 
8914 
  def write(self, oprot):
8915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8917 
      return
8918 
    oprot.writeStructBegin('getComingSoon_result')
8919 
    if self.success is not None:
8920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8922 
      for iter108 in self.success:
8923 
        iter108.write(oprot)
5944 mandeep.dh 8924 
      oprot.writeListEnd()
8925 
      oprot.writeFieldEnd()
8926 
    if self.isex is not None:
8927 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8928 
      self.isex.write(oprot)
8929 
      oprot.writeFieldEnd()
8930 
    oprot.writeFieldStop()
8931 
    oprot.writeStructEnd()
8932 
 
8933 
  def validate(self):
8934 
    return
8935 
 
8936 
 
8937 
  def __repr__(self):
8938 
    L = ['%s=%r' % (key, value)
8939 
      for key, value in self.__dict__.iteritems()]
8940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8941 
 
8942 
  def __eq__(self, other):
8943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8944 
 
8945 
  def __ne__(self, other):
8946 
    return not (self == other)
8947 
 
8948 
class getComingSoonCatalogIds_args:
8949 
  """
8950 
  Attributes:
8951 
   - beginIndex
8952 
   - totalItems
8953 
   - brand
8954 
   - category
8955 
  """
8956 
 
8957 
  thrift_spec = (
8958 
    None, # 0
8959 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8960 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8961 
    (3, TType.STRING, 'brand', None, None, ), # 3
8962 
    (4, TType.I64, 'category', None, None, ), # 4
8963 
  )
8964 
 
8965 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8966 
    self.beginIndex = beginIndex
8967 
    self.totalItems = totalItems
8968 
    self.brand = brand
8969 
    self.category = category
8970 
 
8971 
  def read(self, iprot):
8972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8974 
      return
8975 
    iprot.readStructBegin()
8976 
    while True:
8977 
      (fname, ftype, fid) = iprot.readFieldBegin()
8978 
      if ftype == TType.STOP:
8979 
        break
8980 
      if fid == 1:
8981 
        if ftype == TType.I64:
8982 
          self.beginIndex = iprot.readI64();
8983 
        else:
8984 
          iprot.skip(ftype)
8985 
      elif fid == 2:
8986 
        if ftype == TType.I64:
8987 
          self.totalItems = iprot.readI64();
8988 
        else:
8989 
          iprot.skip(ftype)
8990 
      elif fid == 3:
8991 
        if ftype == TType.STRING:
8992 
          self.brand = iprot.readString();
8993 
        else:
8994 
          iprot.skip(ftype)
8995 
      elif fid == 4:
8996 
        if ftype == TType.I64:
8997 
          self.category = iprot.readI64();
8998 
        else:
8999 
          iprot.skip(ftype)
9000 
      else:
9001 
        iprot.skip(ftype)
9002 
      iprot.readFieldEnd()
9003 
    iprot.readStructEnd()
9004 
 
9005 
  def write(self, oprot):
9006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9008 
      return
9009 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9010 
    if self.beginIndex is not None:
9011 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9012 
      oprot.writeI64(self.beginIndex)
9013 
      oprot.writeFieldEnd()
9014 
    if self.totalItems is not None:
9015 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9016 
      oprot.writeI64(self.totalItems)
9017 
      oprot.writeFieldEnd()
9018 
    if self.brand is not None:
9019 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9020 
      oprot.writeString(self.brand)
9021 
      oprot.writeFieldEnd()
9022 
    if self.category is not None:
9023 
      oprot.writeFieldBegin('category', TType.I64, 4)
9024 
      oprot.writeI64(self.category)
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 getComingSoonCatalogIds_result:
9045 
  """
9046 
  Attributes:
9047 
   - success
9048 
   - cex
9049 
  """
9050 
 
9051 
  thrift_spec = (
9052 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9053 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9054 
  )
9055 
 
9056 
  def __init__(self, success=None, cex=None,):
9057 
    self.success = success
9058 
    self.cex = cex
9059 
 
9060 
  def read(self, iprot):
9061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9063 
      return
9064 
    iprot.readStructBegin()
9065 
    while True:
9066 
      (fname, ftype, fid) = iprot.readFieldBegin()
9067 
      if ftype == TType.STOP:
9068 
        break
9069 
      if fid == 0:
9070 
        if ftype == TType.LIST:
9071 
          self.success = []
7438 amit.gupta 9072 
          (_etype112, _size109) = iprot.readListBegin()
9073 
          for _i113 in xrange(_size109):
9074 
            _elem114 = iprot.readI64();
9075 
            self.success.append(_elem114)
5944 mandeep.dh 9076 
          iprot.readListEnd()
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      elif fid == 1:
9080 
        if ftype == TType.STRUCT:
9081 
          self.cex = CatalogServiceException()
9082 
          self.cex.read(iprot)
9083 
        else:
9084 
          iprot.skip(ftype)
9085 
      else:
9086 
        iprot.skip(ftype)
9087 
      iprot.readFieldEnd()
9088 
    iprot.readStructEnd()
9089 
 
9090 
  def write(self, oprot):
9091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9093 
      return
9094 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9095 
    if self.success is not None:
9096 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9097 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9098 
      for iter115 in self.success:
9099 
        oprot.writeI64(iter115)
5944 mandeep.dh 9100 
      oprot.writeListEnd()
9101 
      oprot.writeFieldEnd()
9102 
    if self.cex is not None:
9103 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9104 
      self.cex.write(oprot)
9105 
      oprot.writeFieldEnd()
9106 
    oprot.writeFieldStop()
9107 
    oprot.writeStructEnd()
9108 
 
9109 
  def validate(self):
9110 
    return
9111 
 
9112 
 
9113 
  def __repr__(self):
9114 
    L = ['%s=%r' % (key, value)
9115 
      for key, value in self.__dict__.iteritems()]
9116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9117 
 
9118 
  def __eq__(self, other):
9119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9120 
 
9121 
  def __ne__(self, other):
9122 
    return not (self == other)
9123 
 
9124 
class getComingSoonCount_args:
9125 
 
9126 
  thrift_spec = (
9127 
  )
9128 
 
9129 
  def read(self, iprot):
9130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9132 
      return
9133 
    iprot.readStructBegin()
9134 
    while True:
9135 
      (fname, ftype, fid) = iprot.readFieldBegin()
9136 
      if ftype == TType.STOP:
9137 
        break
9138 
      else:
9139 
        iprot.skip(ftype)
9140 
      iprot.readFieldEnd()
9141 
    iprot.readStructEnd()
9142 
 
9143 
  def write(self, oprot):
9144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9146 
      return
9147 
    oprot.writeStructBegin('getComingSoonCount_args')
9148 
    oprot.writeFieldStop()
9149 
    oprot.writeStructEnd()
9150 
 
9151 
  def validate(self):
9152 
    return
9153 
 
9154 
 
9155 
  def __repr__(self):
9156 
    L = ['%s=%r' % (key, value)
9157 
      for key, value in self.__dict__.iteritems()]
9158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9159 
 
9160 
  def __eq__(self, other):
9161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9162 
 
9163 
  def __ne__(self, other):
9164 
    return not (self == other)
9165 
 
9166 
class getComingSoonCount_result:
9167 
  """
9168 
  Attributes:
9169 
   - success
9170 
   - cex
9171 
  """
9172 
 
9173 
  thrift_spec = (
9174 
    (0, TType.I64, 'success', None, None, ), # 0
9175 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9176 
  )
9177 
 
9178 
  def __init__(self, success=None, cex=None,):
9179 
    self.success = success
9180 
    self.cex = cex
9181 
 
9182 
  def read(self, iprot):
9183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9185 
      return
9186 
    iprot.readStructBegin()
9187 
    while True:
9188 
      (fname, ftype, fid) = iprot.readFieldBegin()
9189 
      if ftype == TType.STOP:
9190 
        break
9191 
      if fid == 0:
9192 
        if ftype == TType.I64:
9193 
          self.success = iprot.readI64();
9194 
        else:
9195 
          iprot.skip(ftype)
9196 
      elif fid == 1:
9197 
        if ftype == TType.STRUCT:
9198 
          self.cex = CatalogServiceException()
9199 
          self.cex.read(iprot)
9200 
        else:
9201 
          iprot.skip(ftype)
9202 
      else:
9203 
        iprot.skip(ftype)
9204 
      iprot.readFieldEnd()
9205 
    iprot.readStructEnd()
9206 
 
9207 
  def write(self, oprot):
9208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9210 
      return
9211 
    oprot.writeStructBegin('getComingSoonCount_result')
9212 
    if self.success is not None:
9213 
      oprot.writeFieldBegin('success', TType.I64, 0)
9214 
      oprot.writeI64(self.success)
9215 
      oprot.writeFieldEnd()
9216 
    if self.cex is not None:
9217 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9218 
      self.cex.write(oprot)
9219 
      oprot.writeFieldEnd()
9220 
    oprot.writeFieldStop()
9221 
    oprot.writeStructEnd()
9222 
 
9223 
  def validate(self):
9224 
    return
9225 
 
9226 
 
9227 
  def __repr__(self):
9228 
    L = ['%s=%r' % (key, value)
9229 
      for key, value in self.__dict__.iteritems()]
9230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9231 
 
9232 
  def __eq__(self, other):
9233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9234 
 
9235 
  def __ne__(self, other):
9236 
    return not (self == other)
9237 
 
9238 
class getLatestArrivals_args:
9239 
 
9240 
  thrift_spec = (
9241 
  )
9242 
 
9243 
  def read(self, iprot):
9244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9246 
      return
9247 
    iprot.readStructBegin()
9248 
    while True:
9249 
      (fname, ftype, fid) = iprot.readFieldBegin()
9250 
      if ftype == TType.STOP:
9251 
        break
9252 
      else:
9253 
        iprot.skip(ftype)
9254 
      iprot.readFieldEnd()
9255 
    iprot.readStructEnd()
9256 
 
9257 
  def write(self, oprot):
9258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9260 
      return
9261 
    oprot.writeStructBegin('getLatestArrivals_args')
9262 
    oprot.writeFieldStop()
9263 
    oprot.writeStructEnd()
9264 
 
9265 
  def validate(self):
9266 
    return
9267 
 
9268 
 
9269 
  def __repr__(self):
9270 
    L = ['%s=%r' % (key, value)
9271 
      for key, value in self.__dict__.iteritems()]
9272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9273 
 
9274 
  def __eq__(self, other):
9275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9276 
 
9277 
  def __ne__(self, other):
9278 
    return not (self == other)
9279 
 
9280 
class getLatestArrivals_result:
9281 
  """
9282 
  Attributes:
9283 
   - success
9284 
   - isex
9285 
  """
9286 
 
9287 
  thrift_spec = (
9288 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9289 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9290 
  )
9291 
 
9292 
  def __init__(self, success=None, isex=None,):
9293 
    self.success = success
9294 
    self.isex = isex
9295 
 
9296 
  def read(self, iprot):
9297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9299 
      return
9300 
    iprot.readStructBegin()
9301 
    while True:
9302 
      (fname, ftype, fid) = iprot.readFieldBegin()
9303 
      if ftype == TType.STOP:
9304 
        break
9305 
      if fid == 0:
9306 
        if ftype == TType.LIST:
9307 
          self.success = []
7438 amit.gupta 9308 
          (_etype119, _size116) = iprot.readListBegin()
9309 
          for _i120 in xrange(_size116):
9310 
            _elem121 = Item()
9311 
            _elem121.read(iprot)
9312 
            self.success.append(_elem121)
5944 mandeep.dh 9313 
          iprot.readListEnd()
9314 
        else:
9315 
          iprot.skip(ftype)
9316 
      elif fid == 1:
9317 
        if ftype == TType.STRUCT:
9318 
          self.isex = CatalogServiceException()
9319 
          self.isex.read(iprot)
9320 
        else:
9321 
          iprot.skip(ftype)
9322 
      else:
9323 
        iprot.skip(ftype)
9324 
      iprot.readFieldEnd()
9325 
    iprot.readStructEnd()
9326 
 
9327 
  def write(self, oprot):
9328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9330 
      return
9331 
    oprot.writeStructBegin('getLatestArrivals_result')
9332 
    if self.success is not None:
9333 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9334 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9335 
      for iter122 in self.success:
9336 
        iter122.write(oprot)
5944 mandeep.dh 9337 
      oprot.writeListEnd()
9338 
      oprot.writeFieldEnd()
9339 
    if self.isex is not None:
9340 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9341 
      self.isex.write(oprot)
9342 
      oprot.writeFieldEnd()
9343 
    oprot.writeFieldStop()
9344 
    oprot.writeStructEnd()
9345 
 
9346 
  def validate(self):
9347 
    return
9348 
 
9349 
 
9350 
  def __repr__(self):
9351 
    L = ['%s=%r' % (key, value)
9352 
      for key, value in self.__dict__.iteritems()]
9353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9354 
 
9355 
  def __eq__(self, other):
9356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9357 
 
9358 
  def __ne__(self, other):
9359 
    return not (self == other)
9360 
 
9361 
class getLatestArrivalsCatalogIds_args:
9362 
  """
9363 
  Attributes:
9364 
   - beginIndex
9365 
   - totalItems
9366 
   - brand
9367 
   - categories
9368 
  """
9369 
 
9370 
  thrift_spec = (
9371 
    None, # 0
9372 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9373 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9374 
    (3, TType.STRING, 'brand', None, None, ), # 3
9375 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9376 
  )
9377 
 
9378 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9379 
    self.beginIndex = beginIndex
9380 
    self.totalItems = totalItems
9381 
    self.brand = brand
9382 
    self.categories = categories
9383 
 
9384 
  def read(self, iprot):
9385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9387 
      return
9388 
    iprot.readStructBegin()
9389 
    while True:
9390 
      (fname, ftype, fid) = iprot.readFieldBegin()
9391 
      if ftype == TType.STOP:
9392 
        break
9393 
      if fid == 1:
9394 
        if ftype == TType.I64:
9395 
          self.beginIndex = iprot.readI64();
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      elif fid == 2:
9399 
        if ftype == TType.I64:
9400 
          self.totalItems = iprot.readI64();
9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      elif fid == 3:
9404 
        if ftype == TType.STRING:
9405 
          self.brand = iprot.readString();
9406 
        else:
9407 
          iprot.skip(ftype)
9408 
      elif fid == 4:
9409 
        if ftype == TType.LIST:
9410 
          self.categories = []
7438 amit.gupta 9411 
          (_etype126, _size123) = iprot.readListBegin()
9412 
          for _i127 in xrange(_size123):
9413 
            _elem128 = iprot.readI64();
9414 
            self.categories.append(_elem128)
5944 mandeep.dh 9415 
          iprot.readListEnd()
9416 
        else:
9417 
          iprot.skip(ftype)
9418 
      else:
9419 
        iprot.skip(ftype)
9420 
      iprot.readFieldEnd()
9421 
    iprot.readStructEnd()
9422 
 
9423 
  def write(self, oprot):
9424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9426 
      return
9427 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9428 
    if self.beginIndex is not None:
9429 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9430 
      oprot.writeI64(self.beginIndex)
9431 
      oprot.writeFieldEnd()
9432 
    if self.totalItems is not None:
9433 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9434 
      oprot.writeI64(self.totalItems)
9435 
      oprot.writeFieldEnd()
9436 
    if self.brand is not None:
9437 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9438 
      oprot.writeString(self.brand)
9439 
      oprot.writeFieldEnd()
9440 
    if self.categories is not None:
9441 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9442 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9443 
      for iter129 in self.categories:
9444 
        oprot.writeI64(iter129)
5944 mandeep.dh 9445 
      oprot.writeListEnd()
9446 
      oprot.writeFieldEnd()
9447 
    oprot.writeFieldStop()
9448 
    oprot.writeStructEnd()
9449 
 
9450 
  def validate(self):
9451 
    return
9452 
 
9453 
 
9454 
  def __repr__(self):
9455 
    L = ['%s=%r' % (key, value)
9456 
      for key, value in self.__dict__.iteritems()]
9457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9458 
 
9459 
  def __eq__(self, other):
9460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9461 
 
9462 
  def __ne__(self, other):
9463 
    return not (self == other)
9464 
 
9465 
class getLatestArrivalsCatalogIds_result:
9466 
  """
9467 
  Attributes:
9468 
   - success
9469 
   - cex
9470 
  """
9471 
 
9472 
  thrift_spec = (
9473 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9474 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9475 
  )
9476 
 
9477 
  def __init__(self, success=None, cex=None,):
9478 
    self.success = success
9479 
    self.cex = cex
9480 
 
9481 
  def read(self, iprot):
9482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9484 
      return
9485 
    iprot.readStructBegin()
9486 
    while True:
9487 
      (fname, ftype, fid) = iprot.readFieldBegin()
9488 
      if ftype == TType.STOP:
9489 
        break
9490 
      if fid == 0:
9491 
        if ftype == TType.LIST:
9492 
          self.success = []
7438 amit.gupta 9493 
          (_etype133, _size130) = iprot.readListBegin()
9494 
          for _i134 in xrange(_size130):
9495 
            _elem135 = iprot.readI64();
9496 
            self.success.append(_elem135)
5944 mandeep.dh 9497 
          iprot.readListEnd()
9498 
        else:
9499 
          iprot.skip(ftype)
9500 
      elif fid == 1:
9501 
        if ftype == TType.STRUCT:
9502 
          self.cex = CatalogServiceException()
9503 
          self.cex.read(iprot)
9504 
        else:
9505 
          iprot.skip(ftype)
9506 
      else:
9507 
        iprot.skip(ftype)
9508 
      iprot.readFieldEnd()
9509 
    iprot.readStructEnd()
9510 
 
9511 
  def write(self, oprot):
9512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9514 
      return
9515 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9516 
    if self.success is not None:
9517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9518 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9519 
      for iter136 in self.success:
9520 
        oprot.writeI64(iter136)
5944 mandeep.dh 9521 
      oprot.writeListEnd()
9522 
      oprot.writeFieldEnd()
9523 
    if self.cex is not None:
9524 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9525 
      self.cex.write(oprot)
9526 
      oprot.writeFieldEnd()
9527 
    oprot.writeFieldStop()
9528 
    oprot.writeStructEnd()
9529 
 
9530 
  def validate(self):
9531 
    return
9532 
 
9533 
 
9534 
  def __repr__(self):
9535 
    L = ['%s=%r' % (key, value)
9536 
      for key, value in self.__dict__.iteritems()]
9537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9538 
 
9539 
  def __eq__(self, other):
9540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9541 
 
9542 
  def __ne__(self, other):
9543 
    return not (self == other)
9544 
 
9545 
class getLatestArrivalsCount_args:
9546 
 
9547 
  thrift_spec = (
9548 
  )
9549 
 
9550 
  def read(self, iprot):
9551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9553 
      return
9554 
    iprot.readStructBegin()
9555 
    while True:
9556 
      (fname, ftype, fid) = iprot.readFieldBegin()
9557 
      if ftype == TType.STOP:
9558 
        break
9559 
      else:
9560 
        iprot.skip(ftype)
9561 
      iprot.readFieldEnd()
9562 
    iprot.readStructEnd()
9563 
 
9564 
  def write(self, oprot):
9565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9567 
      return
9568 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9569 
    oprot.writeFieldStop()
9570 
    oprot.writeStructEnd()
9571 
 
9572 
  def validate(self):
9573 
    return
9574 
 
9575 
 
9576 
  def __repr__(self):
9577 
    L = ['%s=%r' % (key, value)
9578 
      for key, value in self.__dict__.iteritems()]
9579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9580 
 
9581 
  def __eq__(self, other):
9582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9583 
 
9584 
  def __ne__(self, other):
9585 
    return not (self == other)
9586 
 
9587 
class getLatestArrivalsCount_result:
9588 
  """
9589 
  Attributes:
9590 
   - success
9591 
   - cex
9592 
  """
9593 
 
9594 
  thrift_spec = (
9595 
    (0, TType.I64, 'success', None, None, ), # 0
9596 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9597 
  )
9598 
 
9599 
  def __init__(self, success=None, cex=None,):
9600 
    self.success = success
9601 
    self.cex = cex
9602 
 
9603 
  def read(self, iprot):
9604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9606 
      return
9607 
    iprot.readStructBegin()
9608 
    while True:
9609 
      (fname, ftype, fid) = iprot.readFieldBegin()
9610 
      if ftype == TType.STOP:
9611 
        break
9612 
      if fid == 0:
9613 
        if ftype == TType.I64:
9614 
          self.success = iprot.readI64();
9615 
        else:
9616 
          iprot.skip(ftype)
9617 
      elif fid == 1:
9618 
        if ftype == TType.STRUCT:
9619 
          self.cex = CatalogServiceException()
9620 
          self.cex.read(iprot)
9621 
        else:
9622 
          iprot.skip(ftype)
9623 
      else:
9624 
        iprot.skip(ftype)
9625 
      iprot.readFieldEnd()
9626 
    iprot.readStructEnd()
9627 
 
9628 
  def write(self, oprot):
9629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9631 
      return
9632 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9633 
    if self.success is not None:
9634 
      oprot.writeFieldBegin('success', TType.I64, 0)
9635 
      oprot.writeI64(self.success)
9636 
      oprot.writeFieldEnd()
9637 
    if self.cex is not None:
9638 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9639 
      self.cex.write(oprot)
9640 
      oprot.writeFieldEnd()
9641 
    oprot.writeFieldStop()
9642 
    oprot.writeStructEnd()
9643 
 
9644 
  def validate(self):
9645 
    return
9646 
 
9647 
 
9648 
  def __repr__(self):
9649 
    L = ['%s=%r' % (key, value)
9650 
      for key, value in self.__dict__.iteritems()]
9651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9652 
 
9653 
  def __eq__(self, other):
9654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9655 
 
9656 
  def __ne__(self, other):
9657 
    return not (self == other)
9658 
 
9659 
class generateNewEntityID_args:
9660 
 
9661 
  thrift_spec = (
9662 
  )
9663 
 
9664 
  def read(self, iprot):
9665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9667 
      return
9668 
    iprot.readStructBegin()
9669 
    while True:
9670 
      (fname, ftype, fid) = iprot.readFieldBegin()
9671 
      if ftype == TType.STOP:
9672 
        break
9673 
      else:
9674 
        iprot.skip(ftype)
9675 
      iprot.readFieldEnd()
9676 
    iprot.readStructEnd()
9677 
 
9678 
  def write(self, oprot):
9679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9681 
      return
9682 
    oprot.writeStructBegin('generateNewEntityID_args')
9683 
    oprot.writeFieldStop()
9684 
    oprot.writeStructEnd()
9685 
 
9686 
  def validate(self):
9687 
    return
9688 
 
9689 
 
9690 
  def __repr__(self):
9691 
    L = ['%s=%r' % (key, value)
9692 
      for key, value in self.__dict__.iteritems()]
9693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9694 
 
9695 
  def __eq__(self, other):
9696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9697 
 
9698 
  def __ne__(self, other):
9699 
    return not (self == other)
9700 
 
9701 
class generateNewEntityID_result:
9702 
  """
9703 
  Attributes:
9704 
   - success
9705 
  """
9706 
 
9707 
  thrift_spec = (
9708 
    (0, TType.I64, 'success', None, None, ), # 0
9709 
  )
9710 
 
9711 
  def __init__(self, success=None,):
9712 
    self.success = success
9713 
 
9714 
  def read(self, iprot):
9715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9717 
      return
9718 
    iprot.readStructBegin()
9719 
    while True:
9720 
      (fname, ftype, fid) = iprot.readFieldBegin()
9721 
      if ftype == TType.STOP:
9722 
        break
9723 
      if fid == 0:
9724 
        if ftype == TType.I64:
9725 
          self.success = iprot.readI64();
9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      else:
9729 
        iprot.skip(ftype)
9730 
      iprot.readFieldEnd()
9731 
    iprot.readStructEnd()
9732 
 
9733 
  def write(self, oprot):
9734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9736 
      return
9737 
    oprot.writeStructBegin('generateNewEntityID_result')
9738 
    if self.success is not None:
9739 
      oprot.writeFieldBegin('success', TType.I64, 0)
9740 
      oprot.writeI64(self.success)
9741 
      oprot.writeFieldEnd()
9742 
    oprot.writeFieldStop()
9743 
    oprot.writeStructEnd()
9744 
 
9745 
  def validate(self):
9746 
    return
9747 
 
9748 
 
9749 
  def __repr__(self):
9750 
    L = ['%s=%r' % (key, value)
9751 
      for key, value in self.__dict__.iteritems()]
9752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9753 
 
9754 
  def __eq__(self, other):
9755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9756 
 
9757 
  def __ne__(self, other):
9758 
    return not (self == other)
9759 
 
9760 
class addCategory_args:
9761 
  """
9762 
  Attributes:
9763 
   - category
9764 
  """
9765 
 
9766 
  thrift_spec = (
9767 
    None, # 0
9768 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9769 
  )
9770 
 
9771 
  def __init__(self, category=None,):
9772 
    self.category = category
9773 
 
9774 
  def read(self, iprot):
9775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9777 
      return
9778 
    iprot.readStructBegin()
9779 
    while True:
9780 
      (fname, ftype, fid) = iprot.readFieldBegin()
9781 
      if ftype == TType.STOP:
9782 
        break
9783 
      if fid == 1:
9784 
        if ftype == TType.STRUCT:
9785 
          self.category = Category()
9786 
          self.category.read(iprot)
9787 
        else:
9788 
          iprot.skip(ftype)
9789 
      else:
9790 
        iprot.skip(ftype)
9791 
      iprot.readFieldEnd()
9792 
    iprot.readStructEnd()
9793 
 
9794 
  def write(self, oprot):
9795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9797 
      return
9798 
    oprot.writeStructBegin('addCategory_args')
9799 
    if self.category is not None:
9800 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9801 
      self.category.write(oprot)
9802 
      oprot.writeFieldEnd()
9803 
    oprot.writeFieldStop()
9804 
    oprot.writeStructEnd()
9805 
 
9806 
  def validate(self):
9807 
    return
9808 
 
9809 
 
9810 
  def __repr__(self):
9811 
    L = ['%s=%r' % (key, value)
9812 
      for key, value in self.__dict__.iteritems()]
9813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9814 
 
9815 
  def __eq__(self, other):
9816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9817 
 
9818 
  def __ne__(self, other):
9819 
    return not (self == other)
9820 
 
9821 
class addCategory_result:
9822 
  """
9823 
  Attributes:
9824 
   - success
9825 
  """
9826 
 
9827 
  thrift_spec = (
9828 
    (0, TType.BOOL, 'success', None, None, ), # 0
9829 
  )
9830 
 
9831 
  def __init__(self, success=None,):
9832 
    self.success = success
9833 
 
9834 
  def read(self, iprot):
9835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9837 
      return
9838 
    iprot.readStructBegin()
9839 
    while True:
9840 
      (fname, ftype, fid) = iprot.readFieldBegin()
9841 
      if ftype == TType.STOP:
9842 
        break
9843 
      if fid == 0:
9844 
        if ftype == TType.BOOL:
9845 
          self.success = iprot.readBool();
9846 
        else:
9847 
          iprot.skip(ftype)
9848 
      else:
9849 
        iprot.skip(ftype)
9850 
      iprot.readFieldEnd()
9851 
    iprot.readStructEnd()
9852 
 
9853 
  def write(self, oprot):
9854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9856 
      return
9857 
    oprot.writeStructBegin('addCategory_result')
9858 
    if self.success is not None:
9859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9860 
      oprot.writeBool(self.success)
9861 
      oprot.writeFieldEnd()
9862 
    oprot.writeFieldStop()
9863 
    oprot.writeStructEnd()
9864 
 
9865 
  def validate(self):
9866 
    return
9867 
 
9868 
 
9869 
  def __repr__(self):
9870 
    L = ['%s=%r' % (key, value)
9871 
      for key, value in self.__dict__.iteritems()]
9872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9873 
 
9874 
  def __eq__(self, other):
9875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9876 
 
9877 
  def __ne__(self, other):
9878 
    return not (self == other)
9879 
 
9880 
class getCategory_args:
9881 
  """
9882 
  Attributes:
9883 
   - id
9884 
  """
9885 
 
9886 
  thrift_spec = (
9887 
    None, # 0
9888 
    (1, TType.I64, 'id', None, None, ), # 1
9889 
  )
9890 
 
9891 
  def __init__(self, id=None,):
9892 
    self.id = id
9893 
 
9894 
  def read(self, iprot):
9895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9897 
      return
9898 
    iprot.readStructBegin()
9899 
    while True:
9900 
      (fname, ftype, fid) = iprot.readFieldBegin()
9901 
      if ftype == TType.STOP:
9902 
        break
9903 
      if fid == 1:
9904 
        if ftype == TType.I64:
9905 
          self.id = iprot.readI64();
9906 
        else:
9907 
          iprot.skip(ftype)
9908 
      else:
9909 
        iprot.skip(ftype)
9910 
      iprot.readFieldEnd()
9911 
    iprot.readStructEnd()
9912 
 
9913 
  def write(self, oprot):
9914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9916 
      return
9917 
    oprot.writeStructBegin('getCategory_args')
9918 
    if self.id is not None:
9919 
      oprot.writeFieldBegin('id', TType.I64, 1)
9920 
      oprot.writeI64(self.id)
9921 
      oprot.writeFieldEnd()
9922 
    oprot.writeFieldStop()
9923 
    oprot.writeStructEnd()
9924 
 
9925 
  def validate(self):
9926 
    return
9927 
 
9928 
 
9929 
  def __repr__(self):
9930 
    L = ['%s=%r' % (key, value)
9931 
      for key, value in self.__dict__.iteritems()]
9932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9933 
 
9934 
  def __eq__(self, other):
9935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9936 
 
9937 
  def __ne__(self, other):
9938 
    return not (self == other)
9939 
 
9940 
class getCategory_result:
9941 
  """
9942 
  Attributes:
9943 
   - success
9944 
  """
9945 
 
9946 
  thrift_spec = (
9947 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9948 
  )
9949 
 
9950 
  def __init__(self, success=None,):
9951 
    self.success = success
9952 
 
9953 
  def read(self, iprot):
9954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9956 
      return
9957 
    iprot.readStructBegin()
9958 
    while True:
9959 
      (fname, ftype, fid) = iprot.readFieldBegin()
9960 
      if ftype == TType.STOP:
9961 
        break
9962 
      if fid == 0:
9963 
        if ftype == TType.STRUCT:
9964 
          self.success = Category()
9965 
          self.success.read(iprot)
9966 
        else:
9967 
          iprot.skip(ftype)
9968 
      else:
9969 
        iprot.skip(ftype)
9970 
      iprot.readFieldEnd()
9971 
    iprot.readStructEnd()
9972 
 
9973 
  def write(self, oprot):
9974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9976 
      return
9977 
    oprot.writeStructBegin('getCategory_result')
9978 
    if self.success is not None:
9979 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9980 
      self.success.write(oprot)
9981 
      oprot.writeFieldEnd()
9982 
    oprot.writeFieldStop()
9983 
    oprot.writeStructEnd()
9984 
 
9985 
  def validate(self):
9986 
    return
9987 
 
9988 
 
9989 
  def __repr__(self):
9990 
    L = ['%s=%r' % (key, value)
9991 
      for key, value in self.__dict__.iteritems()]
9992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9993 
 
9994 
  def __eq__(self, other):
9995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9996 
 
9997 
  def __ne__(self, other):
9998 
    return not (self == other)
9999 
 
10000 
class getAllCategories_args:
10001 
 
10002 
  thrift_spec = (
10003 
  )
10004 
 
10005 
  def read(self, iprot):
10006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10008 
      return
10009 
    iprot.readStructBegin()
10010 
    while True:
10011 
      (fname, ftype, fid) = iprot.readFieldBegin()
10012 
      if ftype == TType.STOP:
10013 
        break
10014 
      else:
10015 
        iprot.skip(ftype)
10016 
      iprot.readFieldEnd()
10017 
    iprot.readStructEnd()
10018 
 
10019 
  def write(self, oprot):
10020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10022 
      return
10023 
    oprot.writeStructBegin('getAllCategories_args')
10024 
    oprot.writeFieldStop()
10025 
    oprot.writeStructEnd()
10026 
 
10027 
  def validate(self):
10028 
    return
10029 
 
10030 
 
10031 
  def __repr__(self):
10032 
    L = ['%s=%r' % (key, value)
10033 
      for key, value in self.__dict__.iteritems()]
10034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10035 
 
10036 
  def __eq__(self, other):
10037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10038 
 
10039 
  def __ne__(self, other):
10040 
    return not (self == other)
10041 
 
10042 
class getAllCategories_result:
10043 
  """
10044 
  Attributes:
10045 
   - success
10046 
  """
10047 
 
10048 
  thrift_spec = (
10049 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10050 
  )
10051 
 
10052 
  def __init__(self, success=None,):
10053 
    self.success = success
10054 
 
10055 
  def read(self, iprot):
10056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10058 
      return
10059 
    iprot.readStructBegin()
10060 
    while True:
10061 
      (fname, ftype, fid) = iprot.readFieldBegin()
10062 
      if ftype == TType.STOP:
10063 
        break
10064 
      if fid == 0:
10065 
        if ftype == TType.LIST:
10066 
          self.success = []
7438 amit.gupta 10067 
          (_etype140, _size137) = iprot.readListBegin()
10068 
          for _i141 in xrange(_size137):
10069 
            _elem142 = Category()
10070 
            _elem142.read(iprot)
10071 
            self.success.append(_elem142)
5944 mandeep.dh 10072 
          iprot.readListEnd()
10073 
        else:
10074 
          iprot.skip(ftype)
10075 
      else:
10076 
        iprot.skip(ftype)
10077 
      iprot.readFieldEnd()
10078 
    iprot.readStructEnd()
10079 
 
10080 
  def write(self, oprot):
10081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10083 
      return
10084 
    oprot.writeStructBegin('getAllCategories_result')
10085 
    if self.success is not None:
10086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10088 
      for iter143 in self.success:
10089 
        iter143.write(oprot)
5944 mandeep.dh 10090 
      oprot.writeListEnd()
10091 
      oprot.writeFieldEnd()
10092 
    oprot.writeFieldStop()
10093 
    oprot.writeStructEnd()
10094 
 
10095 
  def validate(self):
10096 
    return
10097 
 
10098 
 
10099 
  def __repr__(self):
10100 
    L = ['%s=%r' % (key, value)
10101 
      for key, value in self.__dict__.iteritems()]
10102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10103 
 
10104 
  def __eq__(self, other):
10105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10106 
 
10107 
  def __ne__(self, other):
10108 
    return not (self == other)
10109 
 
10110 
class getAllSimilarItems_args:
10111 
  """
10112 
  Attributes:
10113 
   - itemId
10114 
  """
10115 
 
10116 
  thrift_spec = (
10117 
    None, # 0
10118 
    (1, TType.I64, 'itemId', None, None, ), # 1
10119 
  )
10120 
 
10121 
  def __init__(self, itemId=None,):
10122 
    self.itemId = itemId
10123 
 
10124 
  def read(self, iprot):
10125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10127 
      return
10128 
    iprot.readStructBegin()
10129 
    while True:
10130 
      (fname, ftype, fid) = iprot.readFieldBegin()
10131 
      if ftype == TType.STOP:
10132 
        break
10133 
      if fid == 1:
10134 
        if ftype == TType.I64:
10135 
          self.itemId = iprot.readI64();
10136 
        else:
10137 
          iprot.skip(ftype)
10138 
      else:
10139 
        iprot.skip(ftype)
10140 
      iprot.readFieldEnd()
10141 
    iprot.readStructEnd()
10142 
 
10143 
  def write(self, oprot):
10144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10146 
      return
10147 
    oprot.writeStructBegin('getAllSimilarItems_args')
10148 
    if self.itemId is not None:
10149 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10150 
      oprot.writeI64(self.itemId)
10151 
      oprot.writeFieldEnd()
10152 
    oprot.writeFieldStop()
10153 
    oprot.writeStructEnd()
10154 
 
10155 
  def validate(self):
10156 
    return
10157 
 
10158 
 
10159 
  def __repr__(self):
10160 
    L = ['%s=%r' % (key, value)
10161 
      for key, value in self.__dict__.iteritems()]
10162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10163 
 
10164 
  def __eq__(self, other):
10165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10166 
 
10167 
  def __ne__(self, other):
10168 
    return not (self == other)
10169 
 
10170 
class getAllSimilarItems_result:
10171 
  """
10172 
  Attributes:
10173 
   - success
10174 
  """
10175 
 
10176 
  thrift_spec = (
10177 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10178 
  )
10179 
 
10180 
  def __init__(self, success=None,):
10181 
    self.success = success
10182 
 
10183 
  def read(self, iprot):
10184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10186 
      return
10187 
    iprot.readStructBegin()
10188 
    while True:
10189 
      (fname, ftype, fid) = iprot.readFieldBegin()
10190 
      if ftype == TType.STOP:
10191 
        break
10192 
      if fid == 0:
10193 
        if ftype == TType.LIST:
10194 
          self.success = []
7438 amit.gupta 10195 
          (_etype147, _size144) = iprot.readListBegin()
10196 
          for _i148 in xrange(_size144):
10197 
            _elem149 = Item()
10198 
            _elem149.read(iprot)
10199 
            self.success.append(_elem149)
5944 mandeep.dh 10200 
          iprot.readListEnd()
10201 
        else:
10202 
          iprot.skip(ftype)
10203 
      else:
10204 
        iprot.skip(ftype)
10205 
      iprot.readFieldEnd()
10206 
    iprot.readStructEnd()
10207 
 
10208 
  def write(self, oprot):
10209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10211 
      return
10212 
    oprot.writeStructBegin('getAllSimilarItems_result')
10213 
    if self.success is not None:
10214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10216 
      for iter150 in self.success:
10217 
        iter150.write(oprot)
5944 mandeep.dh 10218 
      oprot.writeListEnd()
10219 
      oprot.writeFieldEnd()
10220 
    oprot.writeFieldStop()
10221 
    oprot.writeStructEnd()
10222 
 
10223 
  def validate(self):
10224 
    return
10225 
 
10226 
 
10227 
  def __repr__(self):
10228 
    L = ['%s=%r' % (key, value)
10229 
      for key, value in self.__dict__.iteritems()]
10230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10231 
 
10232 
  def __eq__(self, other):
10233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10234 
 
10235 
  def __ne__(self, other):
10236 
    return not (self == other)
10237 
 
10238 
class addSimilarItem_args:
10239 
  """
10240 
  Attributes:
10241 
   - itemId
10242 
   - catalogItemId
10243 
  """
10244 
 
10245 
  thrift_spec = (
10246 
    None, # 0
10247 
    (1, TType.I64, 'itemId', None, None, ), # 1
10248 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10249 
  )
10250 
 
10251 
  def __init__(self, itemId=None, catalogItemId=None,):
10252 
    self.itemId = itemId
10253 
    self.catalogItemId = catalogItemId
10254 
 
10255 
  def read(self, iprot):
10256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10258 
      return
10259 
    iprot.readStructBegin()
10260 
    while True:
10261 
      (fname, ftype, fid) = iprot.readFieldBegin()
10262 
      if ftype == TType.STOP:
10263 
        break
10264 
      if fid == 1:
10265 
        if ftype == TType.I64:
10266 
          self.itemId = iprot.readI64();
10267 
        else:
10268 
          iprot.skip(ftype)
10269 
      elif fid == 2:
10270 
        if ftype == TType.I64:
10271 
          self.catalogItemId = iprot.readI64();
10272 
        else:
10273 
          iprot.skip(ftype)
10274 
      else:
10275 
        iprot.skip(ftype)
10276 
      iprot.readFieldEnd()
10277 
    iprot.readStructEnd()
10278 
 
10279 
  def write(self, oprot):
10280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10282 
      return
10283 
    oprot.writeStructBegin('addSimilarItem_args')
10284 
    if self.itemId is not None:
10285 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10286 
      oprot.writeI64(self.itemId)
10287 
      oprot.writeFieldEnd()
10288 
    if self.catalogItemId is not None:
10289 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10290 
      oprot.writeI64(self.catalogItemId)
10291 
      oprot.writeFieldEnd()
10292 
    oprot.writeFieldStop()
10293 
    oprot.writeStructEnd()
10294 
 
10295 
  def validate(self):
10296 
    return
10297 
 
10298 
 
10299 
  def __repr__(self):
10300 
    L = ['%s=%r' % (key, value)
10301 
      for key, value in self.__dict__.iteritems()]
10302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10303 
 
10304 
  def __eq__(self, other):
10305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10306 
 
10307 
  def __ne__(self, other):
10308 
    return not (self == other)
10309 
 
10310 
class addSimilarItem_result:
10311 
  """
10312 
  Attributes:
10313 
   - success
10314 
   - cex
10315 
  """
10316 
 
10317 
  thrift_spec = (
10318 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10319 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10320 
  )
10321 
 
10322 
  def __init__(self, success=None, cex=None,):
10323 
    self.success = success
10324 
    self.cex = cex
10325 
 
10326 
  def read(self, iprot):
10327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10329 
      return
10330 
    iprot.readStructBegin()
10331 
    while True:
10332 
      (fname, ftype, fid) = iprot.readFieldBegin()
10333 
      if ftype == TType.STOP:
10334 
        break
10335 
      if fid == 0:
10336 
        if ftype == TType.STRUCT:
10337 
          self.success = Item()
10338 
          self.success.read(iprot)
10339 
        else:
10340 
          iprot.skip(ftype)
10341 
      elif fid == 1:
10342 
        if ftype == TType.STRUCT:
10343 
          self.cex = CatalogServiceException()
10344 
          self.cex.read(iprot)
10345 
        else:
10346 
          iprot.skip(ftype)
10347 
      else:
10348 
        iprot.skip(ftype)
10349 
      iprot.readFieldEnd()
10350 
    iprot.readStructEnd()
10351 
 
10352 
  def write(self, oprot):
10353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10355 
      return
10356 
    oprot.writeStructBegin('addSimilarItem_result')
10357 
    if self.success is not None:
10358 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10359 
      self.success.write(oprot)
10360 
      oprot.writeFieldEnd()
10361 
    if self.cex is not None:
10362 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10363 
      self.cex.write(oprot)
10364 
      oprot.writeFieldEnd()
10365 
    oprot.writeFieldStop()
10366 
    oprot.writeStructEnd()
10367 
 
10368 
  def validate(self):
10369 
    return
10370 
 
10371 
 
10372 
  def __repr__(self):
10373 
    L = ['%s=%r' % (key, value)
10374 
      for key, value in self.__dict__.iteritems()]
10375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10376 
 
10377 
  def __eq__(self, other):
10378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10379 
 
10380 
  def __ne__(self, other):
10381 
    return not (self == other)
10382 
 
6512 kshitij.so 10383 
class addTag_args:
10384 
  """
10385 
  Attributes:
10386 
   - displayName
10387 
   - itemId
10388 
  """
10389 
 
10390 
  thrift_spec = (
10391 
    None, # 0
10392 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10393 
    (2, TType.I64, 'itemId', None, None, ), # 2
10394 
  )
10395 
 
10396 
  def __init__(self, displayName=None, itemId=None,):
10397 
    self.displayName = displayName
10398 
    self.itemId = itemId
10399 
 
10400 
  def read(self, iprot):
10401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10403 
      return
10404 
    iprot.readStructBegin()
10405 
    while True:
10406 
      (fname, ftype, fid) = iprot.readFieldBegin()
10407 
      if ftype == TType.STOP:
10408 
        break
10409 
      if fid == 1:
10410 
        if ftype == TType.STRING:
10411 
          self.displayName = iprot.readString();
10412 
        else:
10413 
          iprot.skip(ftype)
10414 
      elif fid == 2:
10415 
        if ftype == TType.I64:
10416 
          self.itemId = iprot.readI64();
10417 
        else:
10418 
          iprot.skip(ftype)
10419 
      else:
10420 
        iprot.skip(ftype)
10421 
      iprot.readFieldEnd()
10422 
    iprot.readStructEnd()
10423 
 
10424 
  def write(self, oprot):
10425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10427 
      return
10428 
    oprot.writeStructBegin('addTag_args')
10429 
    if self.displayName is not None:
10430 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10431 
      oprot.writeString(self.displayName)
10432 
      oprot.writeFieldEnd()
10433 
    if self.itemId is not None:
10434 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10435 
      oprot.writeI64(self.itemId)
10436 
      oprot.writeFieldEnd()
10437 
    oprot.writeFieldStop()
10438 
    oprot.writeStructEnd()
10439 
 
10440 
  def validate(self):
10441 
    return
10442 
 
10443 
 
10444 
  def __repr__(self):
10445 
    L = ['%s=%r' % (key, value)
10446 
      for key, value in self.__dict__.iteritems()]
10447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10448 
 
10449 
  def __eq__(self, other):
10450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10451 
 
10452 
  def __ne__(self, other):
10453 
    return not (self == other)
10454 
 
10455 
class addTag_result:
10456 
  """
10457 
  Attributes:
10458 
   - success
10459 
  """
10460 
 
10461 
  thrift_spec = (
10462 
    (0, TType.BOOL, 'success', None, None, ), # 0
10463 
  )
10464 
 
10465 
  def __init__(self, success=None,):
10466 
    self.success = success
10467 
 
10468 
  def read(self, iprot):
10469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10471 
      return
10472 
    iprot.readStructBegin()
10473 
    while True:
10474 
      (fname, ftype, fid) = iprot.readFieldBegin()
10475 
      if ftype == TType.STOP:
10476 
        break
10477 
      if fid == 0:
10478 
        if ftype == TType.BOOL:
10479 
          self.success = iprot.readBool();
10480 
        else:
10481 
          iprot.skip(ftype)
10482 
      else:
10483 
        iprot.skip(ftype)
10484 
      iprot.readFieldEnd()
10485 
    iprot.readStructEnd()
10486 
 
10487 
  def write(self, oprot):
10488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10490 
      return
10491 
    oprot.writeStructBegin('addTag_result')
10492 
    if self.success is not None:
10493 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10494 
      oprot.writeBool(self.success)
10495 
      oprot.writeFieldEnd()
10496 
    oprot.writeFieldStop()
10497 
    oprot.writeStructEnd()
10498 
 
10499 
  def validate(self):
10500 
    return
10501 
 
10502 
 
10503 
  def __repr__(self):
10504 
    L = ['%s=%r' % (key, value)
10505 
      for key, value in self.__dict__.iteritems()]
10506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10507 
 
10508 
  def __eq__(self, other):
10509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10510 
 
10511 
  def __ne__(self, other):
10512 
    return not (self == other)
10513 
 
10514 
class deleteEntityTag_args:
10515 
  """
10516 
  Attributes:
10517 
   - displayName
10518 
   - itemId
10519 
  """
10520 
 
10521 
  thrift_spec = (
10522 
    None, # 0
10523 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10524 
    (2, TType.I64, 'itemId', None, None, ), # 2
10525 
  )
10526 
 
10527 
  def __init__(self, displayName=None, itemId=None,):
10528 
    self.displayName = displayName
10529 
    self.itemId = itemId
10530 
 
10531 
  def read(self, iprot):
10532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10534 
      return
10535 
    iprot.readStructBegin()
10536 
    while True:
10537 
      (fname, ftype, fid) = iprot.readFieldBegin()
10538 
      if ftype == TType.STOP:
10539 
        break
10540 
      if fid == 1:
10541 
        if ftype == TType.STRING:
10542 
          self.displayName = iprot.readString();
10543 
        else:
10544 
          iprot.skip(ftype)
10545 
      elif fid == 2:
10546 
        if ftype == TType.I64:
10547 
          self.itemId = iprot.readI64();
10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      else:
10551 
        iprot.skip(ftype)
10552 
      iprot.readFieldEnd()
10553 
    iprot.readStructEnd()
10554 
 
10555 
  def write(self, oprot):
10556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10558 
      return
10559 
    oprot.writeStructBegin('deleteEntityTag_args')
10560 
    if self.displayName is not None:
10561 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10562 
      oprot.writeString(self.displayName)
10563 
      oprot.writeFieldEnd()
10564 
    if self.itemId is not None:
10565 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10566 
      oprot.writeI64(self.itemId)
10567 
      oprot.writeFieldEnd()
10568 
    oprot.writeFieldStop()
10569 
    oprot.writeStructEnd()
10570 
 
10571 
  def validate(self):
10572 
    return
10573 
 
10574 
 
10575 
  def __repr__(self):
10576 
    L = ['%s=%r' % (key, value)
10577 
      for key, value in self.__dict__.iteritems()]
10578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10579 
 
10580 
  def __eq__(self, other):
10581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10582 
 
10583 
  def __ne__(self, other):
10584 
    return not (self == other)
10585 
 
10586 
class deleteEntityTag_result:
10587 
  """
10588 
  Attributes:
10589 
   - success
10590 
  """
10591 
 
10592 
  thrift_spec = (
10593 
    (0, TType.BOOL, 'success', None, None, ), # 0
10594 
  )
10595 
 
10596 
  def __init__(self, success=None,):
10597 
    self.success = success
10598 
 
10599 
  def read(self, iprot):
10600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10602 
      return
10603 
    iprot.readStructBegin()
10604 
    while True:
10605 
      (fname, ftype, fid) = iprot.readFieldBegin()
10606 
      if ftype == TType.STOP:
10607 
        break
10608 
      if fid == 0:
10609 
        if ftype == TType.BOOL:
10610 
          self.success = iprot.readBool();
10611 
        else:
10612 
          iprot.skip(ftype)
10613 
      else:
10614 
        iprot.skip(ftype)
10615 
      iprot.readFieldEnd()
10616 
    iprot.readStructEnd()
10617 
 
10618 
  def write(self, oprot):
10619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10621 
      return
10622 
    oprot.writeStructBegin('deleteEntityTag_result')
10623 
    if self.success is not None:
10624 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10625 
      oprot.writeBool(self.success)
10626 
      oprot.writeFieldEnd()
10627 
    oprot.writeFieldStop()
10628 
    oprot.writeStructEnd()
10629 
 
10630 
  def validate(self):
10631 
    return
10632 
 
10633 
 
10634 
  def __repr__(self):
10635 
    L = ['%s=%r' % (key, value)
10636 
      for key, value in self.__dict__.iteritems()]
10637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10638 
 
10639 
  def __eq__(self, other):
10640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10641 
 
10642 
  def __ne__(self, other):
10643 
    return not (self == other)
10644 
 
10645 
class deleteTag_args:
10646 
  """
10647 
  Attributes:
10648 
   - displayName
10649 
  """
10650 
 
10651 
  thrift_spec = (
10652 
    None, # 0
10653 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10654 
  )
10655 
 
10656 
  def __init__(self, displayName=None,):
10657 
    self.displayName = displayName
10658 
 
10659 
  def read(self, iprot):
10660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10662 
      return
10663 
    iprot.readStructBegin()
10664 
    while True:
10665 
      (fname, ftype, fid) = iprot.readFieldBegin()
10666 
      if ftype == TType.STOP:
10667 
        break
10668 
      if fid == 1:
10669 
        if ftype == TType.STRING:
10670 
          self.displayName = iprot.readString();
10671 
        else:
10672 
          iprot.skip(ftype)
10673 
      else:
10674 
        iprot.skip(ftype)
10675 
      iprot.readFieldEnd()
10676 
    iprot.readStructEnd()
10677 
 
10678 
  def write(self, oprot):
10679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10681 
      return
10682 
    oprot.writeStructBegin('deleteTag_args')
10683 
    if self.displayName is not None:
10684 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10685 
      oprot.writeString(self.displayName)
10686 
      oprot.writeFieldEnd()
10687 
    oprot.writeFieldStop()
10688 
    oprot.writeStructEnd()
10689 
 
10690 
  def validate(self):
10691 
    return
10692 
 
10693 
 
10694 
  def __repr__(self):
10695 
    L = ['%s=%r' % (key, value)
10696 
      for key, value in self.__dict__.iteritems()]
10697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10698 
 
10699 
  def __eq__(self, other):
10700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10701 
 
10702 
  def __ne__(self, other):
10703 
    return not (self == other)
10704 
 
10705 
class deleteTag_result:
10706 
  """
10707 
  Attributes:
10708 
   - success
10709 
  """
10710 
 
10711 
  thrift_spec = (
10712 
    (0, TType.BOOL, 'success', None, None, ), # 0
10713 
  )
10714 
 
10715 
  def __init__(self, success=None,):
10716 
    self.success = success
10717 
 
10718 
  def read(self, iprot):
10719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10721 
      return
10722 
    iprot.readStructBegin()
10723 
    while True:
10724 
      (fname, ftype, fid) = iprot.readFieldBegin()
10725 
      if ftype == TType.STOP:
10726 
        break
10727 
      if fid == 0:
10728 
        if ftype == TType.BOOL:
10729 
          self.success = iprot.readBool();
10730 
        else:
10731 
          iprot.skip(ftype)
10732 
      else:
10733 
        iprot.skip(ftype)
10734 
      iprot.readFieldEnd()
10735 
    iprot.readStructEnd()
10736 
 
10737 
  def write(self, oprot):
10738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10740 
      return
10741 
    oprot.writeStructBegin('deleteTag_result')
10742 
    if self.success is not None:
10743 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10744 
      oprot.writeBool(self.success)
10745 
      oprot.writeFieldEnd()
10746 
    oprot.writeFieldStop()
10747 
    oprot.writeStructEnd()
10748 
 
10749 
  def validate(self):
10750 
    return
10751 
 
10752 
 
10753 
  def __repr__(self):
10754 
    L = ['%s=%r' % (key, value)
10755 
      for key, value in self.__dict__.iteritems()]
10756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10757 
 
10758 
  def __eq__(self, other):
10759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10760 
 
10761 
  def __ne__(self, other):
10762 
    return not (self == other)
10763 
 
10764 
class getAllTags_args:
10765 
 
10766 
  thrift_spec = (
10767 
  )
10768 
 
10769 
  def read(self, iprot):
10770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10772 
      return
10773 
    iprot.readStructBegin()
10774 
    while True:
10775 
      (fname, ftype, fid) = iprot.readFieldBegin()
10776 
      if ftype == TType.STOP:
10777 
        break
10778 
      else:
10779 
        iprot.skip(ftype)
10780 
      iprot.readFieldEnd()
10781 
    iprot.readStructEnd()
10782 
 
10783 
  def write(self, oprot):
10784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10786 
      return
10787 
    oprot.writeStructBegin('getAllTags_args')
10788 
    oprot.writeFieldStop()
10789 
    oprot.writeStructEnd()
10790 
 
10791 
  def validate(self):
10792 
    return
10793 
 
10794 
 
10795 
  def __repr__(self):
10796 
    L = ['%s=%r' % (key, value)
10797 
      for key, value in self.__dict__.iteritems()]
10798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10799 
 
10800 
  def __eq__(self, other):
10801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10802 
 
10803 
  def __ne__(self, other):
10804 
    return not (self == other)
10805 
 
10806 
class getAllTags_result:
10807 
  """
10808 
  Attributes:
10809 
   - success
10810 
  """
10811 
 
10812 
  thrift_spec = (
10813 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10814 
  )
10815 
 
10816 
  def __init__(self, success=None,):
10817 
    self.success = success
10818 
 
10819 
  def read(self, iprot):
10820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10822 
      return
10823 
    iprot.readStructBegin()
10824 
    while True:
10825 
      (fname, ftype, fid) = iprot.readFieldBegin()
10826 
      if ftype == TType.STOP:
10827 
        break
10828 
      if fid == 0:
10829 
        if ftype == TType.LIST:
10830 
          self.success = []
7438 amit.gupta 10831 
          (_etype154, _size151) = iprot.readListBegin()
10832 
          for _i155 in xrange(_size151):
10833 
            _elem156 = iprot.readString();
10834 
            self.success.append(_elem156)
6512 kshitij.so 10835 
          iprot.readListEnd()
10836 
        else:
10837 
          iprot.skip(ftype)
10838 
      else:
10839 
        iprot.skip(ftype)
10840 
      iprot.readFieldEnd()
10841 
    iprot.readStructEnd()
10842 
 
10843 
  def write(self, oprot):
10844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10846 
      return
10847 
    oprot.writeStructBegin('getAllTags_result')
10848 
    if self.success is not None:
10849 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10850 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10851 
      for iter157 in self.success:
10852 
        oprot.writeString(iter157)
6512 kshitij.so 10853 
      oprot.writeListEnd()
10854 
      oprot.writeFieldEnd()
10855 
    oprot.writeFieldStop()
10856 
    oprot.writeStructEnd()
10857 
 
10858 
  def validate(self):
10859 
    return
10860 
 
10861 
 
10862 
  def __repr__(self):
10863 
    L = ['%s=%r' % (key, value)
10864 
      for key, value in self.__dict__.iteritems()]
10865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10866 
 
10867 
  def __eq__(self, other):
10868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10869 
 
10870 
  def __ne__(self, other):
10871 
    return not (self == other)
10872 
 
10873 
class getAllEntitiesByTagName_args:
10874 
  """
10875 
  Attributes:
10876 
   - displayName
10877 
  """
10878 
 
10879 
  thrift_spec = (
10880 
    None, # 0
10881 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10882 
  )
10883 
 
10884 
  def __init__(self, displayName=None,):
10885 
    self.displayName = displayName
10886 
 
10887 
  def read(self, iprot):
10888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10890 
      return
10891 
    iprot.readStructBegin()
10892 
    while True:
10893 
      (fname, ftype, fid) = iprot.readFieldBegin()
10894 
      if ftype == TType.STOP:
10895 
        break
10896 
      if fid == 1:
10897 
        if ftype == TType.STRING:
10898 
          self.displayName = iprot.readString();
10899 
        else:
10900 
          iprot.skip(ftype)
10901 
      else:
10902 
        iprot.skip(ftype)
10903 
      iprot.readFieldEnd()
10904 
    iprot.readStructEnd()
10905 
 
10906 
  def write(self, oprot):
10907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10909 
      return
10910 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10911 
    if self.displayName is not None:
10912 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10913 
      oprot.writeString(self.displayName)
10914 
      oprot.writeFieldEnd()
10915 
    oprot.writeFieldStop()
10916 
    oprot.writeStructEnd()
10917 
 
10918 
  def validate(self):
10919 
    return
10920 
 
10921 
 
10922 
  def __repr__(self):
10923 
    L = ['%s=%r' % (key, value)
10924 
      for key, value in self.__dict__.iteritems()]
10925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10926 
 
10927 
  def __eq__(self, other):
10928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10929 
 
10930 
  def __ne__(self, other):
10931 
    return not (self == other)
10932 
 
10933 
class getAllEntitiesByTagName_result:
10934 
  """
10935 
  Attributes:
10936 
   - success
10937 
  """
10938 
 
10939 
  thrift_spec = (
10940 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10941 
  )
10942 
 
10943 
  def __init__(self, success=None,):
10944 
    self.success = success
10945 
 
10946 
  def read(self, iprot):
10947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10949 
      return
10950 
    iprot.readStructBegin()
10951 
    while True:
10952 
      (fname, ftype, fid) = iprot.readFieldBegin()
10953 
      if ftype == TType.STOP:
10954 
        break
10955 
      if fid == 0:
10956 
        if ftype == TType.LIST:
10957 
          self.success = []
7438 amit.gupta 10958 
          (_etype161, _size158) = iprot.readListBegin()
10959 
          for _i162 in xrange(_size158):
10960 
            _elem163 = iprot.readI64();
10961 
            self.success.append(_elem163)
6512 kshitij.so 10962 
          iprot.readListEnd()
10963 
        else:
10964 
          iprot.skip(ftype)
10965 
      else:
10966 
        iprot.skip(ftype)
10967 
      iprot.readFieldEnd()
10968 
    iprot.readStructEnd()
10969 
 
10970 
  def write(self, oprot):
10971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10973 
      return
10974 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10975 
    if self.success is not None:
10976 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10977 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10978 
      for iter164 in self.success:
10979 
        oprot.writeI64(iter164)
6512 kshitij.so 10980 
      oprot.writeListEnd()
10981 
      oprot.writeFieldEnd()
10982 
    oprot.writeFieldStop()
10983 
    oprot.writeStructEnd()
10984 
 
10985 
  def validate(self):
10986 
    return
10987 
 
10988 
 
10989 
  def __repr__(self):
10990 
    L = ['%s=%r' % (key, value)
10991 
      for key, value in self.__dict__.iteritems()]
10992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10993 
 
10994 
  def __eq__(self, other):
10995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10996 
 
10997 
  def __ne__(self, other):
10998 
    return not (self == other)
10999 
 
6845 amit.gupta 11000 
class getAllEntityTags_args:
11001 
 
11002 
  thrift_spec = (
11003 
  )
11004 
 
11005 
  def read(self, iprot):
11006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11008 
      return
11009 
    iprot.readStructBegin()
11010 
    while True:
11011 
      (fname, ftype, fid) = iprot.readFieldBegin()
11012 
      if ftype == TType.STOP:
11013 
        break
11014 
      else:
11015 
        iprot.skip(ftype)
11016 
      iprot.readFieldEnd()
11017 
    iprot.readStructEnd()
11018 
 
11019 
  def write(self, oprot):
11020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11022 
      return
11023 
    oprot.writeStructBegin('getAllEntityTags_args')
11024 
    oprot.writeFieldStop()
11025 
    oprot.writeStructEnd()
11026 
 
11027 
  def validate(self):
11028 
    return
11029 
 
11030 
 
11031 
  def __repr__(self):
11032 
    L = ['%s=%r' % (key, value)
11033 
      for key, value in self.__dict__.iteritems()]
11034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11035 
 
11036 
  def __eq__(self, other):
11037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11038 
 
11039 
  def __ne__(self, other):
11040 
    return not (self == other)
11041 
 
11042 
class getAllEntityTags_result:
11043 
  """
11044 
  Attributes:
11045 
   - success
11046 
  """
11047 
 
11048 
  thrift_spec = (
11049 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11050 
  )
11051 
 
11052 
  def __init__(self, success=None,):
11053 
    self.success = success
11054 
 
11055 
  def read(self, iprot):
11056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11058 
      return
11059 
    iprot.readStructBegin()
11060 
    while True:
11061 
      (fname, ftype, fid) = iprot.readFieldBegin()
11062 
      if ftype == TType.STOP:
11063 
        break
11064 
      if fid == 0:
11065 
        if ftype == TType.MAP:
11066 
          self.success = {}
7438 amit.gupta 11067 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11068 
          for _i169 in xrange(_size165):
11069 
            _key170 = iprot.readI64();
11070 
            _val171 = []
11071 
            (_etype175, _size172) = iprot.readListBegin()
11072 
            for _i176 in xrange(_size172):
11073 
              _elem177 = iprot.readString();
11074 
              _val171.append(_elem177)
6845 amit.gupta 11075 
            iprot.readListEnd()
7438 amit.gupta 11076 
            self.success[_key170] = _val171
6845 amit.gupta 11077 
          iprot.readMapEnd()
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      else:
11081 
        iprot.skip(ftype)
11082 
      iprot.readFieldEnd()
11083 
    iprot.readStructEnd()
11084 
 
11085 
  def write(self, oprot):
11086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11088 
      return
11089 
    oprot.writeStructBegin('getAllEntityTags_result')
11090 
    if self.success is not None:
11091 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11092 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 11093 
      for kiter178,viter179 in self.success.items():
11094 
        oprot.writeI64(kiter178)
11095 
        oprot.writeListBegin(TType.STRING, len(viter179))
11096 
        for iter180 in viter179:
11097 
          oprot.writeString(iter180)
6845 amit.gupta 11098 
        oprot.writeListEnd()
11099 
      oprot.writeMapEnd()
11100 
      oprot.writeFieldEnd()
11101 
    oprot.writeFieldStop()
11102 
    oprot.writeStructEnd()
11103 
 
11104 
  def validate(self):
11105 
    return
11106 
 
11107 
 
11108 
  def __repr__(self):
11109 
    L = ['%s=%r' % (key, value)
11110 
      for key, value in self.__dict__.iteritems()]
11111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11112 
 
11113 
  def __eq__(self, other):
11114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11115 
 
11116 
  def __ne__(self, other):
11117 
    return not (self == other)
11118 
 
6850 kshitij.so 11119 
class addBanner_args:
11120 
  """
11121 
  Attributes:
11122 
   - bannerName
11123 
   - imageName
11124 
   - link
11125 
   - priority
11126 
   - isActive
11127 
   - hasMap
11128 
  """
11129 
 
11130 
  thrift_spec = (
11131 
    None, # 0
11132 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11133 
    (2, TType.STRING, 'imageName', None, None, ), # 2
11134 
    (3, TType.STRING, 'link', None, None, ), # 3
11135 
    (4, TType.I64, 'priority', None, None, ), # 4
11136 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
11137 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
11138 
  )
11139 
 
11140 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
11141 
    self.bannerName = bannerName
11142 
    self.imageName = imageName
11143 
    self.link = link
11144 
    self.priority = priority
11145 
    self.isActive = isActive
11146 
    self.hasMap = hasMap
11147 
 
11148 
  def read(self, iprot):
11149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11151 
      return
11152 
    iprot.readStructBegin()
11153 
    while True:
11154 
      (fname, ftype, fid) = iprot.readFieldBegin()
11155 
      if ftype == TType.STOP:
11156 
        break
11157 
      if fid == 1:
11158 
        if ftype == TType.STRING:
11159 
          self.bannerName = iprot.readString();
11160 
        else:
11161 
          iprot.skip(ftype)
11162 
      elif fid == 2:
11163 
        if ftype == TType.STRING:
11164 
          self.imageName = iprot.readString();
11165 
        else:
11166 
          iprot.skip(ftype)
11167 
      elif fid == 3:
11168 
        if ftype == TType.STRING:
11169 
          self.link = iprot.readString();
11170 
        else:
11171 
          iprot.skip(ftype)
11172 
      elif fid == 4:
11173 
        if ftype == TType.I64:
11174 
          self.priority = iprot.readI64();
11175 
        else:
11176 
          iprot.skip(ftype)
11177 
      elif fid == 5:
11178 
        if ftype == TType.BOOL:
11179 
          self.isActive = iprot.readBool();
11180 
        else:
11181 
          iprot.skip(ftype)
11182 
      elif fid == 6:
11183 
        if ftype == TType.BOOL:
11184 
          self.hasMap = iprot.readBool();
11185 
        else:
11186 
          iprot.skip(ftype)
11187 
      else:
11188 
        iprot.skip(ftype)
11189 
      iprot.readFieldEnd()
11190 
    iprot.readStructEnd()
11191 
 
11192 
  def write(self, oprot):
11193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11195 
      return
11196 
    oprot.writeStructBegin('addBanner_args')
11197 
    if self.bannerName is not None:
11198 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11199 
      oprot.writeString(self.bannerName)
11200 
      oprot.writeFieldEnd()
11201 
    if self.imageName is not None:
11202 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
11203 
      oprot.writeString(self.imageName)
11204 
      oprot.writeFieldEnd()
11205 
    if self.link is not None:
11206 
      oprot.writeFieldBegin('link', TType.STRING, 3)
11207 
      oprot.writeString(self.link)
11208 
      oprot.writeFieldEnd()
11209 
    if self.priority is not None:
11210 
      oprot.writeFieldBegin('priority', TType.I64, 4)
11211 
      oprot.writeI64(self.priority)
11212 
      oprot.writeFieldEnd()
11213 
    if self.isActive is not None:
11214 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
11215 
      oprot.writeBool(self.isActive)
11216 
      oprot.writeFieldEnd()
11217 
    if self.hasMap is not None:
11218 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
11219 
      oprot.writeBool(self.hasMap)
11220 
      oprot.writeFieldEnd()
11221 
    oprot.writeFieldStop()
11222 
    oprot.writeStructEnd()
11223 
 
11224 
  def validate(self):
11225 
    return
11226 
 
11227 
 
11228 
  def __repr__(self):
11229 
    L = ['%s=%r' % (key, value)
11230 
      for key, value in self.__dict__.iteritems()]
11231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11232 
 
11233 
  def __eq__(self, other):
11234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11235 
 
11236 
  def __ne__(self, other):
11237 
    return not (self == other)
11238 
 
11239 
class addBanner_result:
11240 
  """
11241 
  Attributes:
11242 
   - success
11243 
  """
11244 
 
11245 
  thrift_spec = (
11246 
    (0, TType.BOOL, 'success', None, None, ), # 0
11247 
  )
11248 
 
11249 
  def __init__(self, success=None,):
11250 
    self.success = success
11251 
 
11252 
  def read(self, iprot):
11253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11255 
      return
11256 
    iprot.readStructBegin()
11257 
    while True:
11258 
      (fname, ftype, fid) = iprot.readFieldBegin()
11259 
      if ftype == TType.STOP:
11260 
        break
11261 
      if fid == 0:
11262 
        if ftype == TType.BOOL:
11263 
          self.success = iprot.readBool();
11264 
        else:
11265 
          iprot.skip(ftype)
11266 
      else:
11267 
        iprot.skip(ftype)
11268 
      iprot.readFieldEnd()
11269 
    iprot.readStructEnd()
11270 
 
11271 
  def write(self, oprot):
11272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11274 
      return
11275 
    oprot.writeStructBegin('addBanner_result')
11276 
    if self.success is not None:
11277 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11278 
      oprot.writeBool(self.success)
11279 
      oprot.writeFieldEnd()
11280 
    oprot.writeFieldStop()
11281 
    oprot.writeStructEnd()
11282 
 
11283 
  def validate(self):
11284 
    return
11285 
 
11286 
 
11287 
  def __repr__(self):
11288 
    L = ['%s=%r' % (key, value)
11289 
      for key, value in self.__dict__.iteritems()]
11290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11291 
 
11292 
  def __eq__(self, other):
11293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11294 
 
11295 
  def __ne__(self, other):
11296 
    return not (self == other)
11297 
 
11298 
class getAllBanners_args:
11299 
 
11300 
  thrift_spec = (
11301 
  )
11302 
 
11303 
  def read(self, iprot):
11304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11306 
      return
11307 
    iprot.readStructBegin()
11308 
    while True:
11309 
      (fname, ftype, fid) = iprot.readFieldBegin()
11310 
      if ftype == TType.STOP:
11311 
        break
11312 
      else:
11313 
        iprot.skip(ftype)
11314 
      iprot.readFieldEnd()
11315 
    iprot.readStructEnd()
11316 
 
11317 
  def write(self, oprot):
11318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11320 
      return
11321 
    oprot.writeStructBegin('getAllBanners_args')
11322 
    oprot.writeFieldStop()
11323 
    oprot.writeStructEnd()
11324 
 
11325 
  def validate(self):
11326 
    return
11327 
 
11328 
 
11329 
  def __repr__(self):
11330 
    L = ['%s=%r' % (key, value)
11331 
      for key, value in self.__dict__.iteritems()]
11332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11333 
 
11334 
  def __eq__(self, other):
11335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11336 
 
11337 
  def __ne__(self, other):
11338 
    return not (self == other)
11339 
 
11340 
class getAllBanners_result:
11341 
  """
11342 
  Attributes:
11343 
   - success
11344 
  """
11345 
 
11346 
  thrift_spec = (
11347 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11348 
  )
11349 
 
11350 
  def __init__(self, success=None,):
11351 
    self.success = success
11352 
 
11353 
  def read(self, iprot):
11354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11356 
      return
11357 
    iprot.readStructBegin()
11358 
    while True:
11359 
      (fname, ftype, fid) = iprot.readFieldBegin()
11360 
      if ftype == TType.STOP:
11361 
        break
11362 
      if fid == 0:
11363 
        if ftype == TType.LIST:
11364 
          self.success = []
7438 amit.gupta 11365 
          (_etype184, _size181) = iprot.readListBegin()
11366 
          for _i185 in xrange(_size181):
11367 
            _elem186 = iprot.readString();
11368 
            self.success.append(_elem186)
6850 kshitij.so 11369 
          iprot.readListEnd()
11370 
        else:
11371 
          iprot.skip(ftype)
11372 
      else:
11373 
        iprot.skip(ftype)
11374 
      iprot.readFieldEnd()
11375 
    iprot.readStructEnd()
11376 
 
11377 
  def write(self, oprot):
11378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11380 
      return
11381 
    oprot.writeStructBegin('getAllBanners_result')
11382 
    if self.success is not None:
11383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11384 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11385 
      for iter187 in self.success:
11386 
        oprot.writeString(iter187)
6850 kshitij.so 11387 
      oprot.writeListEnd()
11388 
      oprot.writeFieldEnd()
11389 
    oprot.writeFieldStop()
11390 
    oprot.writeStructEnd()
11391 
 
11392 
  def validate(self):
11393 
    return
11394 
 
11395 
 
11396 
  def __repr__(self):
11397 
    L = ['%s=%r' % (key, value)
11398 
      for key, value in self.__dict__.iteritems()]
11399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11400 
 
11401 
  def __eq__(self, other):
11402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11403 
 
11404 
  def __ne__(self, other):
11405 
    return not (self == other)
11406 
 
11407 
class deleteBanner_args:
11408 
  """
11409 
  Attributes:
11410 
   - bannerName
11411 
  """
11412 
 
11413 
  thrift_spec = (
11414 
    None, # 0
11415 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11416 
  )
11417 
 
11418 
  def __init__(self, bannerName=None,):
11419 
    self.bannerName = bannerName
11420 
 
11421 
  def read(self, iprot):
11422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11424 
      return
11425 
    iprot.readStructBegin()
11426 
    while True:
11427 
      (fname, ftype, fid) = iprot.readFieldBegin()
11428 
      if ftype == TType.STOP:
11429 
        break
11430 
      if fid == 1:
11431 
        if ftype == TType.STRING:
11432 
          self.bannerName = iprot.readString();
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      else:
11436 
        iprot.skip(ftype)
11437 
      iprot.readFieldEnd()
11438 
    iprot.readStructEnd()
11439 
 
11440 
  def write(self, oprot):
11441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11443 
      return
11444 
    oprot.writeStructBegin('deleteBanner_args')
11445 
    if self.bannerName is not None:
11446 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11447 
      oprot.writeString(self.bannerName)
11448 
      oprot.writeFieldEnd()
11449 
    oprot.writeFieldStop()
11450 
    oprot.writeStructEnd()
11451 
 
11452 
  def validate(self):
11453 
    return
11454 
 
11455 
 
11456 
  def __repr__(self):
11457 
    L = ['%s=%r' % (key, value)
11458 
      for key, value in self.__dict__.iteritems()]
11459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11460 
 
11461 
  def __eq__(self, other):
11462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11463 
 
11464 
  def __ne__(self, other):
11465 
    return not (self == other)
11466 
 
11467 
class deleteBanner_result:
11468 
  """
11469 
  Attributes:
11470 
   - success
11471 
  """
11472 
 
11473 
  thrift_spec = (
11474 
    (0, TType.BOOL, 'success', None, None, ), # 0
11475 
  )
11476 
 
11477 
  def __init__(self, success=None,):
11478 
    self.success = success
11479 
 
11480 
  def read(self, iprot):
11481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11483 
      return
11484 
    iprot.readStructBegin()
11485 
    while True:
11486 
      (fname, ftype, fid) = iprot.readFieldBegin()
11487 
      if ftype == TType.STOP:
11488 
        break
11489 
      if fid == 0:
11490 
        if ftype == TType.BOOL:
11491 
          self.success = iprot.readBool();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      else:
11495 
        iprot.skip(ftype)
11496 
      iprot.readFieldEnd()
11497 
    iprot.readStructEnd()
11498 
 
11499 
  def write(self, oprot):
11500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11502 
      return
11503 
    oprot.writeStructBegin('deleteBanner_result')
11504 
    if self.success is not None:
11505 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11506 
      oprot.writeBool(self.success)
11507 
      oprot.writeFieldEnd()
11508 
    oprot.writeFieldStop()
11509 
    oprot.writeStructEnd()
11510 
 
11511 
  def validate(self):
11512 
    return
11513 
 
11514 
 
11515 
  def __repr__(self):
11516 
    L = ['%s=%r' % (key, value)
11517 
      for key, value in self.__dict__.iteritems()]
11518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11519 
 
11520 
  def __eq__(self, other):
11521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11522 
 
11523 
  def __ne__(self, other):
11524 
    return not (self == other)
11525 
 
11526 
class getBannerDetails_args:
11527 
  """
11528 
  Attributes:
11529 
   - bannerName
11530 
  """
11531 
 
11532 
  thrift_spec = (
11533 
    None, # 0
11534 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11535 
  )
11536 
 
11537 
  def __init__(self, bannerName=None,):
11538 
    self.bannerName = bannerName
11539 
 
11540 
  def read(self, iprot):
11541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11543 
      return
11544 
    iprot.readStructBegin()
11545 
    while True:
11546 
      (fname, ftype, fid) = iprot.readFieldBegin()
11547 
      if ftype == TType.STOP:
11548 
        break
11549 
      if fid == 1:
11550 
        if ftype == TType.STRING:
11551 
          self.bannerName = iprot.readString();
11552 
        else:
11553 
          iprot.skip(ftype)
11554 
      else:
11555 
        iprot.skip(ftype)
11556 
      iprot.readFieldEnd()
11557 
    iprot.readStructEnd()
11558 
 
11559 
  def write(self, oprot):
11560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11562 
      return
11563 
    oprot.writeStructBegin('getBannerDetails_args')
11564 
    if self.bannerName is not None:
11565 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11566 
      oprot.writeString(self.bannerName)
11567 
      oprot.writeFieldEnd()
11568 
    oprot.writeFieldStop()
11569 
    oprot.writeStructEnd()
11570 
 
11571 
  def validate(self):
11572 
    return
11573 
 
11574 
 
11575 
  def __repr__(self):
11576 
    L = ['%s=%r' % (key, value)
11577 
      for key, value in self.__dict__.iteritems()]
11578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11579 
 
11580 
  def __eq__(self, other):
11581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11582 
 
11583 
  def __ne__(self, other):
11584 
    return not (self == other)
11585 
 
11586 
class getBannerDetails_result:
11587 
  """
11588 
  Attributes:
11589 
   - success
11590 
  """
11591 
 
11592 
  thrift_spec = (
11593 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11594 
  )
11595 
 
11596 
  def __init__(self, success=None,):
11597 
    self.success = success
11598 
 
11599 
  def read(self, iprot):
11600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11602 
      return
11603 
    iprot.readStructBegin()
11604 
    while True:
11605 
      (fname, ftype, fid) = iprot.readFieldBegin()
11606 
      if ftype == TType.STOP:
11607 
        break
11608 
      if fid == 0:
11609 
        if ftype == TType.STRUCT:
11610 
          self.success = Banner()
11611 
          self.success.read(iprot)
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      else:
11615 
        iprot.skip(ftype)
11616 
      iprot.readFieldEnd()
11617 
    iprot.readStructEnd()
11618 
 
11619 
  def write(self, oprot):
11620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11622 
      return
11623 
    oprot.writeStructBegin('getBannerDetails_result')
11624 
    if self.success is not None:
11625 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11626 
      self.success.write(oprot)
11627 
      oprot.writeFieldEnd()
11628 
    oprot.writeFieldStop()
11629 
    oprot.writeStructEnd()
11630 
 
11631 
  def validate(self):
11632 
    return
11633 
 
11634 
 
11635 
  def __repr__(self):
11636 
    L = ['%s=%r' % (key, value)
11637 
      for key, value in self.__dict__.iteritems()]
11638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11639 
 
11640 
  def __eq__(self, other):
11641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11642 
 
11643 
  def __ne__(self, other):
11644 
    return not (self == other)
11645 
 
11646 
class getActiveBanners_args:
11647 
 
11648 
  thrift_spec = (
11649 
  )
11650 
 
11651 
  def read(self, iprot):
11652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11654 
      return
11655 
    iprot.readStructBegin()
11656 
    while True:
11657 
      (fname, ftype, fid) = iprot.readFieldBegin()
11658 
      if ftype == TType.STOP:
11659 
        break
11660 
      else:
11661 
        iprot.skip(ftype)
11662 
      iprot.readFieldEnd()
11663 
    iprot.readStructEnd()
11664 
 
11665 
  def write(self, oprot):
11666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11668 
      return
11669 
    oprot.writeStructBegin('getActiveBanners_args')
11670 
    oprot.writeFieldStop()
11671 
    oprot.writeStructEnd()
11672 
 
11673 
  def validate(self):
11674 
    return
11675 
 
11676 
 
11677 
  def __repr__(self):
11678 
    L = ['%s=%r' % (key, value)
11679 
      for key, value in self.__dict__.iteritems()]
11680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11681 
 
11682 
  def __eq__(self, other):
11683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11684 
 
11685 
  def __ne__(self, other):
11686 
    return not (self == other)
11687 
 
11688 
class getActiveBanners_result:
11689 
  """
11690 
  Attributes:
11691 
   - success
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11696 
  )
11697 
 
11698 
  def __init__(self, success=None,):
11699 
    self.success = success
11700 
 
11701 
  def read(self, iprot):
11702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11704 
      return
11705 
    iprot.readStructBegin()
11706 
    while True:
11707 
      (fname, ftype, fid) = iprot.readFieldBegin()
11708 
      if ftype == TType.STOP:
11709 
        break
11710 
      if fid == 0:
11711 
        if ftype == TType.LIST:
11712 
          self.success = []
7438 amit.gupta 11713 
          (_etype191, _size188) = iprot.readListBegin()
11714 
          for _i192 in xrange(_size188):
11715 
            _elem193 = Banner()
11716 
            _elem193.read(iprot)
11717 
            self.success.append(_elem193)
6850 kshitij.so 11718 
          iprot.readListEnd()
11719 
        else:
11720 
          iprot.skip(ftype)
11721 
      else:
11722 
        iprot.skip(ftype)
11723 
      iprot.readFieldEnd()
11724 
    iprot.readStructEnd()
11725 
 
11726 
  def write(self, oprot):
11727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11729 
      return
11730 
    oprot.writeStructBegin('getActiveBanners_result')
11731 
    if self.success is not None:
11732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11734 
      for iter194 in self.success:
11735 
        iter194.write(oprot)
6850 kshitij.so 11736 
      oprot.writeListEnd()
11737 
      oprot.writeFieldEnd()
11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
6849 kshitij.so 11756 
class addBannerMap_args:
11757 
  """
11758 
  Attributes:
11759 
   - bannerName
11760 
   - mapLink
11761 
   - coordinates
11762 
  """
11763 
 
11764 
  thrift_spec = (
11765 
    None, # 0
11766 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11767 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11768 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11769 
  )
11770 
 
11771 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11772 
    self.bannerName = bannerName
11773 
    self.mapLink = mapLink
11774 
    self.coordinates = coordinates
11775 
 
11776 
  def read(self, iprot):
11777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11779 
      return
11780 
    iprot.readStructBegin()
11781 
    while True:
11782 
      (fname, ftype, fid) = iprot.readFieldBegin()
11783 
      if ftype == TType.STOP:
11784 
        break
11785 
      if fid == 1:
11786 
        if ftype == TType.STRING:
11787 
          self.bannerName = iprot.readString();
11788 
        else:
11789 
          iprot.skip(ftype)
11790 
      elif fid == 2:
11791 
        if ftype == TType.STRING:
11792 
          self.mapLink = iprot.readString();
11793 
        else:
11794 
          iprot.skip(ftype)
11795 
      elif fid == 3:
11796 
        if ftype == TType.STRING:
11797 
          self.coordinates = iprot.readString();
11798 
        else:
11799 
          iprot.skip(ftype)
11800 
      else:
11801 
        iprot.skip(ftype)
11802 
      iprot.readFieldEnd()
11803 
    iprot.readStructEnd()
11804 
 
11805 
  def write(self, oprot):
11806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11808 
      return
11809 
    oprot.writeStructBegin('addBannerMap_args')
11810 
    if self.bannerName is not None:
11811 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11812 
      oprot.writeString(self.bannerName)
11813 
      oprot.writeFieldEnd()
11814 
    if self.mapLink is not None:
11815 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11816 
      oprot.writeString(self.mapLink)
11817 
      oprot.writeFieldEnd()
11818 
    if self.coordinates is not None:
11819 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11820 
      oprot.writeString(self.coordinates)
11821 
      oprot.writeFieldEnd()
11822 
    oprot.writeFieldStop()
11823 
    oprot.writeStructEnd()
11824 
 
11825 
  def validate(self):
11826 
    return
11827 
 
11828 
 
11829 
  def __repr__(self):
11830 
    L = ['%s=%r' % (key, value)
11831 
      for key, value in self.__dict__.iteritems()]
11832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11833 
 
11834 
  def __eq__(self, other):
11835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11836 
 
11837 
  def __ne__(self, other):
11838 
    return not (self == other)
11839 
 
11840 
class addBannerMap_result:
11841 
  """
11842 
  Attributes:
11843 
   - success
11844 
  """
11845 
 
11846 
  thrift_spec = (
11847 
    (0, TType.BOOL, 'success', None, None, ), # 0
11848 
  )
11849 
 
11850 
  def __init__(self, success=None,):
11851 
    self.success = success
11852 
 
11853 
  def read(self, iprot):
11854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11856 
      return
11857 
    iprot.readStructBegin()
11858 
    while True:
11859 
      (fname, ftype, fid) = iprot.readFieldBegin()
11860 
      if ftype == TType.STOP:
11861 
        break
11862 
      if fid == 0:
11863 
        if ftype == TType.BOOL:
11864 
          self.success = iprot.readBool();
11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      else:
11868 
        iprot.skip(ftype)
11869 
      iprot.readFieldEnd()
11870 
    iprot.readStructEnd()
11871 
 
11872 
  def write(self, oprot):
11873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11875 
      return
11876 
    oprot.writeStructBegin('addBannerMap_result')
11877 
    if self.success is not None:
11878 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11879 
      oprot.writeBool(self.success)
11880 
      oprot.writeFieldEnd()
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
11899 
class deleteBannerMap_args:
11900 
  """
11901 
  Attributes:
11902 
   - bannerName
11903 
  """
11904 
 
11905 
  thrift_spec = (
11906 
    None, # 0
11907 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11908 
  )
11909 
 
11910 
  def __init__(self, bannerName=None,):
11911 
    self.bannerName = bannerName
11912 
 
11913 
  def read(self, iprot):
11914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11916 
      return
11917 
    iprot.readStructBegin()
11918 
    while True:
11919 
      (fname, ftype, fid) = iprot.readFieldBegin()
11920 
      if ftype == TType.STOP:
11921 
        break
11922 
      if fid == 1:
11923 
        if ftype == TType.STRING:
11924 
          self.bannerName = iprot.readString();
11925 
        else:
11926 
          iprot.skip(ftype)
11927 
      else:
11928 
        iprot.skip(ftype)
11929 
      iprot.readFieldEnd()
11930 
    iprot.readStructEnd()
11931 
 
11932 
  def write(self, oprot):
11933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11935 
      return
11936 
    oprot.writeStructBegin('deleteBannerMap_args')
11937 
    if self.bannerName is not None:
11938 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11939 
      oprot.writeString(self.bannerName)
11940 
      oprot.writeFieldEnd()
11941 
    oprot.writeFieldStop()
11942 
    oprot.writeStructEnd()
11943 
 
11944 
  def validate(self):
11945 
    return
11946 
 
11947 
 
11948 
  def __repr__(self):
11949 
    L = ['%s=%r' % (key, value)
11950 
      for key, value in self.__dict__.iteritems()]
11951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11952 
 
11953 
  def __eq__(self, other):
11954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11955 
 
11956 
  def __ne__(self, other):
11957 
    return not (self == other)
11958 
 
11959 
class deleteBannerMap_result:
11960 
  """
11961 
  Attributes:
11962 
   - success
11963 
  """
11964 
 
11965 
  thrift_spec = (
11966 
    (0, TType.BOOL, 'success', None, None, ), # 0
11967 
  )
11968 
 
11969 
  def __init__(self, success=None,):
11970 
    self.success = success
11971 
 
11972 
  def read(self, iprot):
11973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11975 
      return
11976 
    iprot.readStructBegin()
11977 
    while True:
11978 
      (fname, ftype, fid) = iprot.readFieldBegin()
11979 
      if ftype == TType.STOP:
11980 
        break
11981 
      if fid == 0:
11982 
        if ftype == TType.BOOL:
11983 
          self.success = iprot.readBool();
11984 
        else:
11985 
          iprot.skip(ftype)
11986 
      else:
11987 
        iprot.skip(ftype)
11988 
      iprot.readFieldEnd()
11989 
    iprot.readStructEnd()
11990 
 
11991 
  def write(self, oprot):
11992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11994 
      return
11995 
    oprot.writeStructBegin('deleteBannerMap_result')
11996 
    if self.success is not None:
11997 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11998 
      oprot.writeBool(self.success)
11999 
      oprot.writeFieldEnd()
12000 
    oprot.writeFieldStop()
12001 
    oprot.writeStructEnd()
12002 
 
12003 
  def validate(self):
12004 
    return
12005 
 
12006 
 
12007 
  def __repr__(self):
12008 
    L = ['%s=%r' % (key, value)
12009 
      for key, value in self.__dict__.iteritems()]
12010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12011 
 
12012 
  def __eq__(self, other):
12013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12014 
 
12015 
  def __ne__(self, other):
12016 
    return not (self == other)
12017 
 
12018 
class getBannerMapDetails_args:
12019 
  """
12020 
  Attributes:
12021 
   - bannerName
12022 
  """
12023 
 
12024 
  thrift_spec = (
12025 
    None, # 0
12026 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12027 
  )
12028 
 
12029 
  def __init__(self, bannerName=None,):
12030 
    self.bannerName = bannerName
12031 
 
12032 
  def read(self, iprot):
12033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12035 
      return
12036 
    iprot.readStructBegin()
12037 
    while True:
12038 
      (fname, ftype, fid) = iprot.readFieldBegin()
12039 
      if ftype == TType.STOP:
12040 
        break
12041 
      if fid == 1:
12042 
        if ftype == TType.STRING:
12043 
          self.bannerName = iprot.readString();
12044 
        else:
12045 
          iprot.skip(ftype)
12046 
      else:
12047 
        iprot.skip(ftype)
12048 
      iprot.readFieldEnd()
12049 
    iprot.readStructEnd()
12050 
 
12051 
  def write(self, oprot):
12052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12054 
      return
12055 
    oprot.writeStructBegin('getBannerMapDetails_args')
12056 
    if self.bannerName is not None:
12057 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12058 
      oprot.writeString(self.bannerName)
12059 
      oprot.writeFieldEnd()
12060 
    oprot.writeFieldStop()
12061 
    oprot.writeStructEnd()
12062 
 
12063 
  def validate(self):
12064 
    return
12065 
 
12066 
 
12067 
  def __repr__(self):
12068 
    L = ['%s=%r' % (key, value)
12069 
      for key, value in self.__dict__.iteritems()]
12070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12071 
 
12072 
  def __eq__(self, other):
12073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12074 
 
12075 
  def __ne__(self, other):
12076 
    return not (self == other)
12077 
 
12078 
class getBannerMapDetails_result:
12079 
  """
12080 
  Attributes:
12081 
   - success
12082 
  """
12083 
 
12084 
  thrift_spec = (
12085 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
12086 
  )
12087 
 
12088 
  def __init__(self, success=None,):
12089 
    self.success = success
12090 
 
12091 
  def read(self, iprot):
12092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12094 
      return
12095 
    iprot.readStructBegin()
12096 
    while True:
12097 
      (fname, ftype, fid) = iprot.readFieldBegin()
12098 
      if ftype == TType.STOP:
12099 
        break
12100 
      if fid == 0:
12101 
        if ftype == TType.LIST:
12102 
          self.success = []
7438 amit.gupta 12103 
          (_etype198, _size195) = iprot.readListBegin()
12104 
          for _i199 in xrange(_size195):
12105 
            _elem200 = BannerMap()
12106 
            _elem200.read(iprot)
12107 
            self.success.append(_elem200)
6849 kshitij.so 12108 
          iprot.readListEnd()
12109 
        else:
12110 
          iprot.skip(ftype)
12111 
      else:
12112 
        iprot.skip(ftype)
12113 
      iprot.readFieldEnd()
12114 
    iprot.readStructEnd()
12115 
 
12116 
  def write(self, oprot):
12117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12119 
      return
12120 
    oprot.writeStructBegin('getBannerMapDetails_result')
12121 
    if self.success is not None:
12122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12123 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12124 
      for iter201 in self.success:
12125 
        iter201.write(oprot)
6849 kshitij.so 12126 
      oprot.writeListEnd()
12127 
      oprot.writeFieldEnd()
12128 
    oprot.writeFieldStop()
12129 
    oprot.writeStructEnd()
12130 
 
12131 
  def validate(self):
12132 
    return
12133 
 
12134 
 
12135 
  def __repr__(self):
12136 
    L = ['%s=%r' % (key, value)
12137 
      for key, value in self.__dict__.iteritems()]
12138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12139 
 
12140 
  def __eq__(self, other):
12141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12142 
 
12143 
  def __ne__(self, other):
12144 
    return not (self == other)
12145 
 
5944 mandeep.dh 12146 
class deleteSimilarItem_args:
12147 
  """
12148 
  Attributes:
12149 
   - itemId
12150 
   - catalogItemId
12151 
  """
12152 
 
12153 
  thrift_spec = (
12154 
    None, # 0
12155 
    (1, TType.I64, 'itemId', None, None, ), # 1
12156 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12157 
  )
12158 
 
12159 
  def __init__(self, itemId=None, catalogItemId=None,):
12160 
    self.itemId = itemId
12161 
    self.catalogItemId = catalogItemId
12162 
 
12163 
  def read(self, iprot):
12164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12166 
      return
12167 
    iprot.readStructBegin()
12168 
    while True:
12169 
      (fname, ftype, fid) = iprot.readFieldBegin()
12170 
      if ftype == TType.STOP:
12171 
        break
12172 
      if fid == 1:
12173 
        if ftype == TType.I64:
12174 
          self.itemId = iprot.readI64();
12175 
        else:
12176 
          iprot.skip(ftype)
12177 
      elif fid == 2:
12178 
        if ftype == TType.I64:
12179 
          self.catalogItemId = iprot.readI64();
12180 
        else:
12181 
          iprot.skip(ftype)
12182 
      else:
12183 
        iprot.skip(ftype)
12184 
      iprot.readFieldEnd()
12185 
    iprot.readStructEnd()
12186 
 
12187 
  def write(self, oprot):
12188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12190 
      return
12191 
    oprot.writeStructBegin('deleteSimilarItem_args')
12192 
    if self.itemId is not None:
12193 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12194 
      oprot.writeI64(self.itemId)
12195 
      oprot.writeFieldEnd()
12196 
    if self.catalogItemId is not None:
12197 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12198 
      oprot.writeI64(self.catalogItemId)
12199 
      oprot.writeFieldEnd()
12200 
    oprot.writeFieldStop()
12201 
    oprot.writeStructEnd()
12202 
 
12203 
  def validate(self):
12204 
    return
12205 
 
12206 
 
12207 
  def __repr__(self):
12208 
    L = ['%s=%r' % (key, value)
12209 
      for key, value in self.__dict__.iteritems()]
12210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12211 
 
12212 
  def __eq__(self, other):
12213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12214 
 
12215 
  def __ne__(self, other):
12216 
    return not (self == other)
12217 
 
12218 
class deleteSimilarItem_result:
12219 
  """
12220 
  Attributes:
12221 
   - success
12222 
   - cex
12223 
  """
12224 
 
12225 
  thrift_spec = (
12226 
    (0, TType.BOOL, 'success', None, None, ), # 0
12227 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12228 
  )
12229 
 
12230 
  def __init__(self, success=None, cex=None,):
12231 
    self.success = success
12232 
    self.cex = cex
12233 
 
12234 
  def read(self, iprot):
12235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12237 
      return
12238 
    iprot.readStructBegin()
12239 
    while True:
12240 
      (fname, ftype, fid) = iprot.readFieldBegin()
12241 
      if ftype == TType.STOP:
12242 
        break
12243 
      if fid == 0:
12244 
        if ftype == TType.BOOL:
12245 
          self.success = iprot.readBool();
12246 
        else:
12247 
          iprot.skip(ftype)
12248 
      elif fid == 1:
12249 
        if ftype == TType.STRUCT:
12250 
          self.cex = CatalogServiceException()
12251 
          self.cex.read(iprot)
12252 
        else:
12253 
          iprot.skip(ftype)
12254 
      else:
12255 
        iprot.skip(ftype)
12256 
      iprot.readFieldEnd()
12257 
    iprot.readStructEnd()
12258 
 
12259 
  def write(self, oprot):
12260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12262 
      return
12263 
    oprot.writeStructBegin('deleteSimilarItem_result')
12264 
    if self.success is not None:
12265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12266 
      oprot.writeBool(self.success)
12267 
      oprot.writeFieldEnd()
12268 
    if self.cex is not None:
12269 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12270 
      self.cex.write(oprot)
12271 
      oprot.writeFieldEnd()
12272 
    oprot.writeFieldStop()
12273 
    oprot.writeStructEnd()
12274 
 
12275 
  def validate(self):
12276 
    return
12277 
 
12278 
 
12279 
  def __repr__(self):
12280 
    L = ['%s=%r' % (key, value)
12281 
      for key, value in self.__dict__.iteritems()]
12282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12283 
 
12284 
  def __eq__(self, other):
12285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12286 
 
12287 
  def __ne__(self, other):
12288 
    return not (self == other)
12289 
 
12290 
class checkSimilarItem_args:
12291 
  """
12292 
  Attributes:
12293 
   - brand
12294 
   - modelNumber
12295 
   - modelName
12296 
   - color
12297 
  """
12298 
 
12299 
  thrift_spec = (
12300 
    None, # 0
12301 
    (1, TType.STRING, 'brand', None, None, ), # 1
12302 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
12303 
    (3, TType.STRING, 'modelName', None, None, ), # 3
12304 
    (4, TType.STRING, 'color', None, None, ), # 4
12305 
  )
12306 
 
12307 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
12308 
    self.brand = brand
12309 
    self.modelNumber = modelNumber
12310 
    self.modelName = modelName
12311 
    self.color = color
12312 
 
12313 
  def read(self, iprot):
12314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12316 
      return
12317 
    iprot.readStructBegin()
12318 
    while True:
12319 
      (fname, ftype, fid) = iprot.readFieldBegin()
12320 
      if ftype == TType.STOP:
12321 
        break
12322 
      if fid == 1:
12323 
        if ftype == TType.STRING:
12324 
          self.brand = iprot.readString();
12325 
        else:
12326 
          iprot.skip(ftype)
12327 
      elif fid == 2:
12328 
        if ftype == TType.STRING:
12329 
          self.modelNumber = iprot.readString();
12330 
        else:
12331 
          iprot.skip(ftype)
12332 
      elif fid == 3:
12333 
        if ftype == TType.STRING:
12334 
          self.modelName = iprot.readString();
12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      elif fid == 4:
12338 
        if ftype == TType.STRING:
12339 
          self.color = iprot.readString();
12340 
        else:
12341 
          iprot.skip(ftype)
12342 
      else:
12343 
        iprot.skip(ftype)
12344 
      iprot.readFieldEnd()
12345 
    iprot.readStructEnd()
12346 
 
12347 
  def write(self, oprot):
12348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12350 
      return
12351 
    oprot.writeStructBegin('checkSimilarItem_args')
12352 
    if self.brand is not None:
12353 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
12354 
      oprot.writeString(self.brand)
12355 
      oprot.writeFieldEnd()
12356 
    if self.modelNumber is not None:
12357 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
12358 
      oprot.writeString(self.modelNumber)
12359 
      oprot.writeFieldEnd()
12360 
    if self.modelName is not None:
12361 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12362 
      oprot.writeString(self.modelName)
12363 
      oprot.writeFieldEnd()
12364 
    if self.color is not None:
12365 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12366 
      oprot.writeString(self.color)
12367 
      oprot.writeFieldEnd()
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 checkSimilarItem_result:
12387 
  """
12388 
  Attributes:
12389 
   - success
12390 
  """
12391 
 
12392 
  thrift_spec = (
12393 
    (0, TType.I64, 'success', None, 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.I64:
12410 
          self.success = iprot.readI64();
12411 
        else:
12412 
          iprot.skip(ftype)
12413 
      else:
12414 
        iprot.skip(ftype)
12415 
      iprot.readFieldEnd()
12416 
    iprot.readStructEnd()
12417 
 
12418 
  def write(self, oprot):
12419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12421 
      return
12422 
    oprot.writeStructBegin('checkSimilarItem_result')
12423 
    if self.success is not None:
12424 
      oprot.writeFieldBegin('success', TType.I64, 0)
12425 
      oprot.writeI64(self.success)
12426 
      oprot.writeFieldEnd()
12427 
    oprot.writeFieldStop()
12428 
    oprot.writeStructEnd()
12429 
 
12430 
  def validate(self):
12431 
    return
12432 
 
12433 
 
12434 
  def __repr__(self):
12435 
    L = ['%s=%r' % (key, value)
12436 
      for key, value in self.__dict__.iteritems()]
12437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12438 
 
12439 
  def __eq__(self, other):
12440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12441 
 
12442 
  def __ne__(self, other):
12443 
    return not (self == other)
12444 
 
12445 
class validateRiskyStatus_args:
12446 
  """
12447 
  Attributes:
12448 
   - itemId
12449 
  """
12450 
 
12451 
  thrift_spec = (
12452 
    None, # 0
12453 
    (1, TType.I64, 'itemId', None, None, ), # 1
12454 
  )
12455 
 
12456 
  def __init__(self, itemId=None,):
12457 
    self.itemId = itemId
12458 
 
12459 
  def read(self, iprot):
12460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12462 
      return
12463 
    iprot.readStructBegin()
12464 
    while True:
12465 
      (fname, ftype, fid) = iprot.readFieldBegin()
12466 
      if ftype == TType.STOP:
12467 
        break
12468 
      if fid == 1:
12469 
        if ftype == TType.I64:
12470 
          self.itemId = iprot.readI64();
12471 
        else:
12472 
          iprot.skip(ftype)
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
12482 
    oprot.writeStructBegin('validateRiskyStatus_args')
12483 
    if self.itemId is not None:
12484 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12485 
      oprot.writeI64(self.itemId)
12486 
      oprot.writeFieldEnd()
12487 
    oprot.writeFieldStop()
12488 
    oprot.writeStructEnd()
12489 
 
12490 
  def validate(self):
12491 
    return
12492 
 
12493 
 
12494 
  def __repr__(self):
12495 
    L = ['%s=%r' % (key, value)
12496 
      for key, value in self.__dict__.iteritems()]
12497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12498 
 
12499 
  def __eq__(self, other):
12500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12501 
 
12502 
  def __ne__(self, other):
12503 
    return not (self == other)
12504 
 
12505 
class validateRiskyStatus_result:
12506 
 
12507 
  thrift_spec = (
12508 
  )
12509 
 
12510 
  def read(self, iprot):
12511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12513 
      return
12514 
    iprot.readStructBegin()
12515 
    while True:
12516 
      (fname, ftype, fid) = iprot.readFieldBegin()
12517 
      if ftype == TType.STOP:
12518 
        break
12519 
      else:
12520 
        iprot.skip(ftype)
12521 
      iprot.readFieldEnd()
12522 
    iprot.readStructEnd()
12523 
 
12524 
  def write(self, oprot):
12525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12527 
      return
12528 
    oprot.writeStructBegin('validateRiskyStatus_result')
12529 
    oprot.writeFieldStop()
12530 
    oprot.writeStructEnd()
12531 
 
12532 
  def validate(self):
12533 
    return
12534 
 
12535 
 
12536 
  def __repr__(self):
12537 
    L = ['%s=%r' % (key, value)
12538 
      for key, value in self.__dict__.iteritems()]
12539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12540 
 
12541 
  def __eq__(self, other):
12542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12543 
 
12544 
  def __ne__(self, other):
12545 
    return not (self == other)
12546 
 
12547 
class changeItemRiskyFlag_args:
12548 
  """
12549 
  Attributes:
12550 
   - itemId
12551 
   - risky
12552 
  """
12553 
 
12554 
  thrift_spec = (
12555 
    None, # 0
12556 
    (1, TType.I64, 'itemId', None, None, ), # 1
12557 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12558 
  )
12559 
 
12560 
  def __init__(self, itemId=None, risky=None,):
12561 
    self.itemId = itemId
12562 
    self.risky = risky
12563 
 
12564 
  def read(self, iprot):
12565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12567 
      return
12568 
    iprot.readStructBegin()
12569 
    while True:
12570 
      (fname, ftype, fid) = iprot.readFieldBegin()
12571 
      if ftype == TType.STOP:
12572 
        break
12573 
      if fid == 1:
12574 
        if ftype == TType.I64:
12575 
          self.itemId = iprot.readI64();
12576 
        else:
12577 
          iprot.skip(ftype)
12578 
      elif fid == 2:
12579 
        if ftype == TType.BOOL:
12580 
          self.risky = iprot.readBool();
12581 
        else:
12582 
          iprot.skip(ftype)
12583 
      else:
12584 
        iprot.skip(ftype)
12585 
      iprot.readFieldEnd()
12586 
    iprot.readStructEnd()
12587 
 
12588 
  def write(self, oprot):
12589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12591 
      return
12592 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12593 
    if self.itemId is not None:
12594 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12595 
      oprot.writeI64(self.itemId)
12596 
      oprot.writeFieldEnd()
12597 
    if self.risky is not None:
12598 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12599 
      oprot.writeBool(self.risky)
12600 
      oprot.writeFieldEnd()
12601 
    oprot.writeFieldStop()
12602 
    oprot.writeStructEnd()
12603 
 
12604 
  def validate(self):
12605 
    return
12606 
 
12607 
 
12608 
  def __repr__(self):
12609 
    L = ['%s=%r' % (key, value)
12610 
      for key, value in self.__dict__.iteritems()]
12611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12612 
 
12613 
  def __eq__(self, other):
12614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12615 
 
12616 
  def __ne__(self, other):
12617 
    return not (self == other)
12618 
 
12619 
class changeItemRiskyFlag_result:
12620 
 
12621 
  thrift_spec = (
12622 
  )
12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
12633 
      else:
12634 
        iprot.skip(ftype)
12635 
      iprot.readFieldEnd()
12636 
    iprot.readStructEnd()
12637 
 
12638 
  def write(self, oprot):
12639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12641 
      return
12642 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12643 
    oprot.writeFieldStop()
12644 
    oprot.writeStructEnd()
12645 
 
12646 
  def validate(self):
12647 
    return
12648 
 
12649 
 
12650 
  def __repr__(self):
12651 
    L = ['%s=%r' % (key, value)
12652 
      for key, value in self.__dict__.iteritems()]
12653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12654 
 
12655 
  def __eq__(self, other):
12656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12657 
 
12658 
  def __ne__(self, other):
12659 
    return not (self == other)
12660 
 
12661 
class getItemsByRiskyFlag_args:
12662 
 
12663 
  thrift_spec = (
12664 
  )
12665 
 
12666 
  def read(self, iprot):
12667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12669 
      return
12670 
    iprot.readStructBegin()
12671 
    while True:
12672 
      (fname, ftype, fid) = iprot.readFieldBegin()
12673 
      if ftype == TType.STOP:
12674 
        break
12675 
      else:
12676 
        iprot.skip(ftype)
12677 
      iprot.readFieldEnd()
12678 
    iprot.readStructEnd()
12679 
 
12680 
  def write(self, oprot):
12681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12683 
      return
12684 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12685 
    oprot.writeFieldStop()
12686 
    oprot.writeStructEnd()
12687 
 
12688 
  def validate(self):
12689 
    return
12690 
 
12691 
 
12692 
  def __repr__(self):
12693 
    L = ['%s=%r' % (key, value)
12694 
      for key, value in self.__dict__.iteritems()]
12695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12696 
 
12697 
  def __eq__(self, other):
12698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12699 
 
12700 
  def __ne__(self, other):
12701 
    return not (self == other)
12702 
 
12703 
class getItemsByRiskyFlag_result:
12704 
  """
12705 
  Attributes:
12706 
   - success
12707 
  """
12708 
 
12709 
  thrift_spec = (
12710 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12711 
  )
12712 
 
12713 
  def __init__(self, success=None,):
12714 
    self.success = success
12715 
 
12716 
  def read(self, iprot):
12717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12719 
      return
12720 
    iprot.readStructBegin()
12721 
    while True:
12722 
      (fname, ftype, fid) = iprot.readFieldBegin()
12723 
      if ftype == TType.STOP:
12724 
        break
12725 
      if fid == 0:
12726 
        if ftype == TType.LIST:
12727 
          self.success = []
7438 amit.gupta 12728 
          (_etype205, _size202) = iprot.readListBegin()
12729 
          for _i206 in xrange(_size202):
12730 
            _elem207 = Item()
12731 
            _elem207.read(iprot)
12732 
            self.success.append(_elem207)
5944 mandeep.dh 12733 
          iprot.readListEnd()
12734 
        else:
12735 
          iprot.skip(ftype)
12736 
      else:
12737 
        iprot.skip(ftype)
12738 
      iprot.readFieldEnd()
12739 
    iprot.readStructEnd()
12740 
 
12741 
  def write(self, oprot):
12742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12744 
      return
12745 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12746 
    if self.success is not None:
12747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12749 
      for iter208 in self.success:
12750 
        iter208.write(oprot)
5944 mandeep.dh 12751 
      oprot.writeListEnd()
12752 
      oprot.writeFieldEnd()
12753 
    oprot.writeFieldStop()
12754 
    oprot.writeStructEnd()
12755 
 
12756 
  def validate(self):
12757 
    return
12758 
 
12759 
 
12760 
  def __repr__(self):
12761 
    L = ['%s=%r' % (key, value)
12762 
      for key, value in self.__dict__.iteritems()]
12763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12764 
 
12765 
  def __eq__(self, other):
12766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12767 
 
12768 
  def __ne__(self, other):
12769 
    return not (self == other)
12770 
 
12771 
class getItemsForMasterSheet_args:
12772 
  """
12773 
  Attributes:
12774 
   - category
12775 
   - brand
12776 
  """
12777 
 
12778 
  thrift_spec = (
12779 
    None, # 0
12780 
    (1, TType.STRING, 'category', None, None, ), # 1
12781 
    (2, TType.STRING, 'brand', None, None, ), # 2
12782 
  )
12783 
 
12784 
  def __init__(self, category=None, brand=None,):
12785 
    self.category = category
12786 
    self.brand = brand
12787 
 
12788 
  def read(self, iprot):
12789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12791 
      return
12792 
    iprot.readStructBegin()
12793 
    while True:
12794 
      (fname, ftype, fid) = iprot.readFieldBegin()
12795 
      if ftype == TType.STOP:
12796 
        break
12797 
      if fid == 1:
12798 
        if ftype == TType.STRING:
12799 
          self.category = iprot.readString();
12800 
        else:
12801 
          iprot.skip(ftype)
12802 
      elif fid == 2:
12803 
        if ftype == TType.STRING:
12804 
          self.brand = iprot.readString();
12805 
        else:
12806 
          iprot.skip(ftype)
12807 
      else:
12808 
        iprot.skip(ftype)
12809 
      iprot.readFieldEnd()
12810 
    iprot.readStructEnd()
12811 
 
12812 
  def write(self, oprot):
12813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12815 
      return
12816 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12817 
    if self.category is not None:
12818 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12819 
      oprot.writeString(self.category)
12820 
      oprot.writeFieldEnd()
12821 
    if self.brand is not None:
12822 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12823 
      oprot.writeString(self.brand)
12824 
      oprot.writeFieldEnd()
12825 
    oprot.writeFieldStop()
12826 
    oprot.writeStructEnd()
12827 
 
12828 
  def validate(self):
12829 
    return
12830 
 
12831 
 
12832 
  def __repr__(self):
12833 
    L = ['%s=%r' % (key, value)
12834 
      for key, value in self.__dict__.iteritems()]
12835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12836 
 
12837 
  def __eq__(self, other):
12838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12839 
 
12840 
  def __ne__(self, other):
12841 
    return not (self == other)
12842 
 
12843 
class getItemsForMasterSheet_result:
12844 
  """
12845 
  Attributes:
12846 
   - success
12847 
  """
12848 
 
12849 
  thrift_spec = (
12850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12851 
  )
12852 
 
12853 
  def __init__(self, success=None,):
12854 
    self.success = success
12855 
 
12856 
  def read(self, iprot):
12857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12859 
      return
12860 
    iprot.readStructBegin()
12861 
    while True:
12862 
      (fname, ftype, fid) = iprot.readFieldBegin()
12863 
      if ftype == TType.STOP:
12864 
        break
12865 
      if fid == 0:
12866 
        if ftype == TType.LIST:
12867 
          self.success = []
7438 amit.gupta 12868 
          (_etype212, _size209) = iprot.readListBegin()
12869 
          for _i213 in xrange(_size209):
12870 
            _elem214 = Item()
12871 
            _elem214.read(iprot)
12872 
            self.success.append(_elem214)
5944 mandeep.dh 12873 
          iprot.readListEnd()
12874 
        else:
12875 
          iprot.skip(ftype)
12876 
      else:
12877 
        iprot.skip(ftype)
12878 
      iprot.readFieldEnd()
12879 
    iprot.readStructEnd()
12880 
 
12881 
  def write(self, oprot):
12882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12884 
      return
12885 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12886 
    if self.success is not None:
12887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12889 
      for iter215 in self.success:
12890 
        iter215.write(oprot)
5944 mandeep.dh 12891 
      oprot.writeListEnd()
12892 
      oprot.writeFieldEnd()
12893 
    oprot.writeFieldStop()
12894 
    oprot.writeStructEnd()
12895 
 
12896 
  def validate(self):
12897 
    return
12898 
 
12899 
 
12900 
  def __repr__(self):
12901 
    L = ['%s=%r' % (key, value)
12902 
      for key, value in self.__dict__.iteritems()]
12903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12904 
 
12905 
  def __eq__(self, other):
12906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12907 
 
12908 
  def __ne__(self, other):
12909 
    return not (self == other)
12910 
 
12911 
class getSimilarItemsCatalogIds_args:
12912 
  """
12913 
  Attributes:
12914 
   - beginIndex
12915 
   - totalItems
12916 
   - itemId
12917 
  """
12918 
 
12919 
  thrift_spec = (
12920 
    None, # 0
12921 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12922 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12923 
    (3, TType.I64, 'itemId', None, None, ), # 3
12924 
  )
12925 
 
12926 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12927 
    self.beginIndex = beginIndex
12928 
    self.totalItems = totalItems
12929 
    self.itemId = itemId
12930 
 
12931 
  def read(self, iprot):
12932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12934 
      return
12935 
    iprot.readStructBegin()
12936 
    while True:
12937 
      (fname, ftype, fid) = iprot.readFieldBegin()
12938 
      if ftype == TType.STOP:
12939 
        break
12940 
      if fid == 1:
12941 
        if ftype == TType.I64:
12942 
          self.beginIndex = iprot.readI64();
12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      elif fid == 2:
12946 
        if ftype == TType.I64:
12947 
          self.totalItems = iprot.readI64();
12948 
        else:
12949 
          iprot.skip(ftype)
12950 
      elif fid == 3:
12951 
        if ftype == TType.I64:
12952 
          self.itemId = iprot.readI64();
12953 
        else:
12954 
          iprot.skip(ftype)
12955 
      else:
12956 
        iprot.skip(ftype)
12957 
      iprot.readFieldEnd()
12958 
    iprot.readStructEnd()
12959 
 
12960 
  def write(self, oprot):
12961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12963 
      return
12964 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12965 
    if self.beginIndex is not None:
12966 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12967 
      oprot.writeI64(self.beginIndex)
12968 
      oprot.writeFieldEnd()
12969 
    if self.totalItems is not None:
12970 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12971 
      oprot.writeI64(self.totalItems)
12972 
      oprot.writeFieldEnd()
12973 
    if self.itemId is not None:
12974 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12975 
      oprot.writeI64(self.itemId)
12976 
      oprot.writeFieldEnd()
12977 
    oprot.writeFieldStop()
12978 
    oprot.writeStructEnd()
12979 
 
12980 
  def validate(self):
12981 
    return
12982 
 
12983 
 
12984 
  def __repr__(self):
12985 
    L = ['%s=%r' % (key, value)
12986 
      for key, value in self.__dict__.iteritems()]
12987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12988 
 
12989 
  def __eq__(self, other):
12990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12991 
 
12992 
  def __ne__(self, other):
12993 
    return not (self == other)
12994 
 
12995 
class getSimilarItemsCatalogIds_result:
12996 
  """
12997 
  Attributes:
12998 
   - success
12999 
  """
13000 
 
13001 
  thrift_spec = (
13002 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13003 
  )
13004 
 
13005 
  def __init__(self, success=None,):
13006 
    self.success = success
13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      if fid == 0:
13018 
        if ftype == TType.LIST:
13019 
          self.success = []
7438 amit.gupta 13020 
          (_etype219, _size216) = iprot.readListBegin()
13021 
          for _i220 in xrange(_size216):
13022 
            _elem221 = iprot.readI64();
13023 
            self.success.append(_elem221)
5944 mandeep.dh 13024 
          iprot.readListEnd()
13025 
        else:
13026 
          iprot.skip(ftype)
13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
13036 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
13037 
    if self.success is not None:
13038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13039 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 13040 
      for iter222 in self.success:
13041 
        oprot.writeI64(iter222)
5944 mandeep.dh 13042 
      oprot.writeListEnd()
13043 
      oprot.writeFieldEnd()
13044 
    oprot.writeFieldStop()
13045 
    oprot.writeStructEnd()
13046 
 
13047 
  def validate(self):
13048 
    return
13049 
 
13050 
 
13051 
  def __repr__(self):
13052 
    L = ['%s=%r' % (key, value)
13053 
      for key, value in self.__dict__.iteritems()]
13054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13055 
 
13056 
  def __eq__(self, other):
13057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13058 
 
13059 
  def __ne__(self, other):
13060 
    return not (self == other)
13061 
 
13062 
class addProductNotification_args:
13063 
  """
13064 
  Attributes:
13065 
   - itemId
13066 
   - email
13067 
  """
13068 
 
13069 
  thrift_spec = None
13070 
  def __init__(self, itemId=None, email=None,):
13071 
    self.itemId = itemId
13072 
    self.email = email
13073 
 
13074 
  def read(self, iprot):
13075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13077 
      return
13078 
    iprot.readStructBegin()
13079 
    while True:
13080 
      (fname, ftype, fid) = iprot.readFieldBegin()
13081 
      if ftype == TType.STOP:
13082 
        break
13083 
      if fid == -1:
13084 
        if ftype == TType.I64:
13085 
          self.itemId = iprot.readI64();
13086 
        else:
13087 
          iprot.skip(ftype)
13088 
      elif fid == -2:
13089 
        if ftype == TType.STRING:
13090 
          self.email = iprot.readString();
13091 
        else:
13092 
          iprot.skip(ftype)
13093 
      else:
13094 
        iprot.skip(ftype)
13095 
      iprot.readFieldEnd()
13096 
    iprot.readStructEnd()
13097 
 
13098 
  def write(self, oprot):
13099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13101 
      return
13102 
    oprot.writeStructBegin('addProductNotification_args')
13103 
    if self.email is not None:
13104 
      oprot.writeFieldBegin('email', TType.STRING, -2)
13105 
      oprot.writeString(self.email)
13106 
      oprot.writeFieldEnd()
13107 
    if self.itemId is not None:
13108 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
13109 
      oprot.writeI64(self.itemId)
13110 
      oprot.writeFieldEnd()
13111 
    oprot.writeFieldStop()
13112 
    oprot.writeStructEnd()
13113 
 
13114 
  def validate(self):
13115 
    return
13116 
 
13117 
 
13118 
  def __repr__(self):
13119 
    L = ['%s=%r' % (key, value)
13120 
      for key, value in self.__dict__.iteritems()]
13121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13122 
 
13123 
  def __eq__(self, other):
13124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13125 
 
13126 
  def __ne__(self, other):
13127 
    return not (self == other)
13128 
 
13129 
class addProductNotification_result:
13130 
  """
13131 
  Attributes:
13132 
   - success
13133 
  """
13134 
 
13135 
  thrift_spec = (
13136 
    (0, TType.BOOL, 'success', None, None, ), # 0
13137 
  )
13138 
 
13139 
  def __init__(self, success=None,):
13140 
    self.success = success
13141 
 
13142 
  def read(self, iprot):
13143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13145 
      return
13146 
    iprot.readStructBegin()
13147 
    while True:
13148 
      (fname, ftype, fid) = iprot.readFieldBegin()
13149 
      if ftype == TType.STOP:
13150 
        break
13151 
      if fid == 0:
13152 
        if ftype == TType.BOOL:
13153 
          self.success = iprot.readBool();
13154 
        else:
13155 
          iprot.skip(ftype)
13156 
      else:
13157 
        iprot.skip(ftype)
13158 
      iprot.readFieldEnd()
13159 
    iprot.readStructEnd()
13160 
 
13161 
  def write(self, oprot):
13162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13164 
      return
13165 
    oprot.writeStructBegin('addProductNotification_result')
13166 
    if self.success is not None:
13167 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13168 
      oprot.writeBool(self.success)
13169 
      oprot.writeFieldEnd()
13170 
    oprot.writeFieldStop()
13171 
    oprot.writeStructEnd()
13172 
 
13173 
  def validate(self):
13174 
    return
13175 
 
13176 
 
13177 
  def __repr__(self):
13178 
    L = ['%s=%r' % (key, value)
13179 
      for key, value in self.__dict__.iteritems()]
13180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13181 
 
13182 
  def __eq__(self, other):
13183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13184 
 
13185 
  def __ne__(self, other):
13186 
    return not (self == other)
13187 
 
13188 
class sendProductNotifications_args:
13189 
 
13190 
  thrift_spec = (
13191 
  )
13192 
 
13193 
  def read(self, iprot):
13194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13196 
      return
13197 
    iprot.readStructBegin()
13198 
    while True:
13199 
      (fname, ftype, fid) = iprot.readFieldBegin()
13200 
      if ftype == TType.STOP:
13201 
        break
13202 
      else:
13203 
        iprot.skip(ftype)
13204 
      iprot.readFieldEnd()
13205 
    iprot.readStructEnd()
13206 
 
13207 
  def write(self, oprot):
13208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13210 
      return
13211 
    oprot.writeStructBegin('sendProductNotifications_args')
13212 
    oprot.writeFieldStop()
13213 
    oprot.writeStructEnd()
13214 
 
13215 
  def validate(self):
13216 
    return
13217 
 
13218 
 
13219 
  def __repr__(self):
13220 
    L = ['%s=%r' % (key, value)
13221 
      for key, value in self.__dict__.iteritems()]
13222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13223 
 
13224 
  def __eq__(self, other):
13225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13226 
 
13227 
  def __ne__(self, other):
13228 
    return not (self == other)
13229 
 
13230 
class sendProductNotifications_result:
13231 
  """
13232 
  Attributes:
13233 
   - success
13234 
  """
13235 
 
13236 
  thrift_spec = (
13237 
    (0, TType.BOOL, 'success', None, None, ), # 0
13238 
  )
13239 
 
13240 
  def __init__(self, success=None,):
13241 
    self.success = success
13242 
 
13243 
  def read(self, iprot):
13244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13246 
      return
13247 
    iprot.readStructBegin()
13248 
    while True:
13249 
      (fname, ftype, fid) = iprot.readFieldBegin()
13250 
      if ftype == TType.STOP:
13251 
        break
13252 
      if fid == 0:
13253 
        if ftype == TType.BOOL:
13254 
          self.success = iprot.readBool();
13255 
        else:
13256 
          iprot.skip(ftype)
13257 
      else:
13258 
        iprot.skip(ftype)
13259 
      iprot.readFieldEnd()
13260 
    iprot.readStructEnd()
13261 
 
13262 
  def write(self, oprot):
13263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13265 
      return
13266 
    oprot.writeStructBegin('sendProductNotifications_result')
13267 
    if self.success is not None:
13268 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13269 
      oprot.writeBool(self.success)
13270 
      oprot.writeFieldEnd()
13271 
    oprot.writeFieldStop()
13272 
    oprot.writeStructEnd()
13273 
 
13274 
  def validate(self):
13275 
    return
13276 
 
13277 
 
13278 
  def __repr__(self):
13279 
    L = ['%s=%r' % (key, value)
13280 
      for key, value in self.__dict__.iteritems()]
13281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13282 
 
13283 
  def __eq__(self, other):
13284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13285 
 
13286 
  def __ne__(self, other):
13287 
    return not (self == other)
13288 
 
13289 
class getAllBrandsByCategory_args:
13290 
  """
13291 
  Attributes:
13292 
   - categoryId
13293 
  """
13294 
 
13295 
  thrift_spec = (
13296 
    None, # 0
13297 
    (1, TType.I64, 'categoryId', None, None, ), # 1
13298 
  )
13299 
 
13300 
  def __init__(self, categoryId=None,):
13301 
    self.categoryId = categoryId
13302 
 
13303 
  def read(self, iprot):
13304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13306 
      return
13307 
    iprot.readStructBegin()
13308 
    while True:
13309 
      (fname, ftype, fid) = iprot.readFieldBegin()
13310 
      if ftype == TType.STOP:
13311 
        break
13312 
      if fid == 1:
13313 
        if ftype == TType.I64:
13314 
          self.categoryId = iprot.readI64();
13315 
        else:
13316 
          iprot.skip(ftype)
13317 
      else:
13318 
        iprot.skip(ftype)
13319 
      iprot.readFieldEnd()
13320 
    iprot.readStructEnd()
13321 
 
13322 
  def write(self, oprot):
13323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13325 
      return
13326 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
13327 
    if self.categoryId is not None:
13328 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
13329 
      oprot.writeI64(self.categoryId)
13330 
      oprot.writeFieldEnd()
13331 
    oprot.writeFieldStop()
13332 
    oprot.writeStructEnd()
13333 
 
13334 
  def validate(self):
13335 
    return
13336 
 
13337 
 
13338 
  def __repr__(self):
13339 
    L = ['%s=%r' % (key, value)
13340 
      for key, value in self.__dict__.iteritems()]
13341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13342 
 
13343 
  def __eq__(self, other):
13344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13345 
 
13346 
  def __ne__(self, other):
13347 
    return not (self == other)
13348 
 
13349 
class getAllBrandsByCategory_result:
13350 
  """
13351 
  Attributes:
13352 
   - success
13353 
  """
13354 
 
13355 
  thrift_spec = (
13356 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13357 
  )
13358 
 
13359 
  def __init__(self, success=None,):
13360 
    self.success = success
13361 
 
13362 
  def read(self, iprot):
13363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13365 
      return
13366 
    iprot.readStructBegin()
13367 
    while True:
13368 
      (fname, ftype, fid) = iprot.readFieldBegin()
13369 
      if ftype == TType.STOP:
13370 
        break
13371 
      if fid == 0:
13372 
        if ftype == TType.LIST:
13373 
          self.success = []
7438 amit.gupta 13374 
          (_etype226, _size223) = iprot.readListBegin()
13375 
          for _i227 in xrange(_size223):
13376 
            _elem228 = iprot.readString();
13377 
            self.success.append(_elem228)
5944 mandeep.dh 13378 
          iprot.readListEnd()
13379 
        else:
13380 
          iprot.skip(ftype)
13381 
      else:
13382 
        iprot.skip(ftype)
13383 
      iprot.readFieldEnd()
13384 
    iprot.readStructEnd()
13385 
 
13386 
  def write(self, oprot):
13387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13389 
      return
13390 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
13391 
    if self.success is not None:
13392 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13393 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13394 
      for iter229 in self.success:
13395 
        oprot.writeString(iter229)
5944 mandeep.dh 13396 
      oprot.writeListEnd()
13397 
      oprot.writeFieldEnd()
13398 
    oprot.writeFieldStop()
13399 
    oprot.writeStructEnd()
13400 
 
13401 
  def validate(self):
13402 
    return
13403 
 
13404 
 
13405 
  def __repr__(self):
13406 
    L = ['%s=%r' % (key, value)
13407 
      for key, value in self.__dict__.iteritems()]
13408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13409 
 
13410 
  def __eq__(self, other):
13411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13412 
 
13413 
  def __ne__(self, other):
13414 
    return not (self == other)
13415 
 
13416 
class getAllBrands_args:
13417 
 
13418 
  thrift_spec = (
13419 
  )
13420 
 
13421 
  def read(self, iprot):
13422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13424 
      return
13425 
    iprot.readStructBegin()
13426 
    while True:
13427 
      (fname, ftype, fid) = iprot.readFieldBegin()
13428 
      if ftype == TType.STOP:
13429 
        break
13430 
      else:
13431 
        iprot.skip(ftype)
13432 
      iprot.readFieldEnd()
13433 
    iprot.readStructEnd()
13434 
 
13435 
  def write(self, oprot):
13436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13438 
      return
13439 
    oprot.writeStructBegin('getAllBrands_args')
13440 
    oprot.writeFieldStop()
13441 
    oprot.writeStructEnd()
13442 
 
13443 
  def validate(self):
13444 
    return
13445 
 
13446 
 
13447 
  def __repr__(self):
13448 
    L = ['%s=%r' % (key, value)
13449 
      for key, value in self.__dict__.iteritems()]
13450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13451 
 
13452 
  def __eq__(self, other):
13453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13454 
 
13455 
  def __ne__(self, other):
13456 
    return not (self == other)
13457 
 
13458 
class getAllBrands_result:
13459 
  """
13460 
  Attributes:
13461 
   - success
13462 
  """
13463 
 
13464 
  thrift_spec = (
13465 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13466 
  )
13467 
 
13468 
  def __init__(self, success=None,):
13469 
    self.success = success
13470 
 
13471 
  def read(self, iprot):
13472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13474 
      return
13475 
    iprot.readStructBegin()
13476 
    while True:
13477 
      (fname, ftype, fid) = iprot.readFieldBegin()
13478 
      if ftype == TType.STOP:
13479 
        break
13480 
      if fid == 0:
13481 
        if ftype == TType.LIST:
13482 
          self.success = []
7438 amit.gupta 13483 
          (_etype233, _size230) = iprot.readListBegin()
13484 
          for _i234 in xrange(_size230):
13485 
            _elem235 = iprot.readString();
13486 
            self.success.append(_elem235)
5944 mandeep.dh 13487 
          iprot.readListEnd()
13488 
        else:
13489 
          iprot.skip(ftype)
13490 
      else:
13491 
        iprot.skip(ftype)
13492 
      iprot.readFieldEnd()
13493 
    iprot.readStructEnd()
13494 
 
13495 
  def write(self, oprot):
13496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13498 
      return
13499 
    oprot.writeStructBegin('getAllBrands_result')
13500 
    if self.success is not None:
13501 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13502 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13503 
      for iter236 in self.success:
13504 
        oprot.writeString(iter236)
5944 mandeep.dh 13505 
      oprot.writeListEnd()
13506 
      oprot.writeFieldEnd()
13507 
    oprot.writeFieldStop()
13508 
    oprot.writeStructEnd()
13509 
 
13510 
  def validate(self):
13511 
    return
13512 
 
13513 
 
13514 
  def __repr__(self):
13515 
    L = ['%s=%r' % (key, value)
13516 
      for key, value in self.__dict__.iteritems()]
13517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13518 
 
13519 
  def __eq__(self, other):
13520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13521 
 
13522 
  def __ne__(self, other):
13523 
    return not (self == other)
13524 
 
13525 
class getAllSources_args:
13526 
 
13527 
  thrift_spec = (
13528 
  )
13529 
 
13530 
  def read(self, iprot):
13531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13533 
      return
13534 
    iprot.readStructBegin()
13535 
    while True:
13536 
      (fname, ftype, fid) = iprot.readFieldBegin()
13537 
      if ftype == TType.STOP:
13538 
        break
13539 
      else:
13540 
        iprot.skip(ftype)
13541 
      iprot.readFieldEnd()
13542 
    iprot.readStructEnd()
13543 
 
13544 
  def write(self, oprot):
13545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13547 
      return
13548 
    oprot.writeStructBegin('getAllSources_args')
13549 
    oprot.writeFieldStop()
13550 
    oprot.writeStructEnd()
13551 
 
13552 
  def validate(self):
13553 
    return
13554 
 
13555 
 
13556 
  def __repr__(self):
13557 
    L = ['%s=%r' % (key, value)
13558 
      for key, value in self.__dict__.iteritems()]
13559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13560 
 
13561 
  def __eq__(self, other):
13562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13563 
 
13564 
  def __ne__(self, other):
13565 
    return not (self == other)
13566 
 
13567 
class getAllSources_result:
13568 
  """
13569 
  Attributes:
13570 
   - success
13571 
  """
13572 
 
13573 
  thrift_spec = (
13574 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13575 
  )
13576 
 
13577 
  def __init__(self, success=None,):
13578 
    self.success = success
13579 
 
13580 
  def read(self, iprot):
13581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13583 
      return
13584 
    iprot.readStructBegin()
13585 
    while True:
13586 
      (fname, ftype, fid) = iprot.readFieldBegin()
13587 
      if ftype == TType.STOP:
13588 
        break
13589 
      if fid == 0:
13590 
        if ftype == TType.LIST:
13591 
          self.success = []
7438 amit.gupta 13592 
          (_etype240, _size237) = iprot.readListBegin()
13593 
          for _i241 in xrange(_size237):
13594 
            _elem242 = Source()
13595 
            _elem242.read(iprot)
13596 
            self.success.append(_elem242)
5944 mandeep.dh 13597 
          iprot.readListEnd()
13598 
        else:
13599 
          iprot.skip(ftype)
13600 
      else:
13601 
        iprot.skip(ftype)
13602 
      iprot.readFieldEnd()
13603 
    iprot.readStructEnd()
13604 
 
13605 
  def write(self, oprot):
13606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13608 
      return
13609 
    oprot.writeStructBegin('getAllSources_result')
13610 
    if self.success is not None:
13611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13612 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13613 
      for iter243 in self.success:
13614 
        iter243.write(oprot)
5944 mandeep.dh 13615 
      oprot.writeListEnd()
13616 
      oprot.writeFieldEnd()
13617 
    oprot.writeFieldStop()
13618 
    oprot.writeStructEnd()
13619 
 
13620 
  def validate(self):
13621 
    return
13622 
 
13623 
 
13624 
  def __repr__(self):
13625 
    L = ['%s=%r' % (key, value)
13626 
      for key, value in self.__dict__.iteritems()]
13627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13628 
 
13629 
  def __eq__(self, other):
13630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13631 
 
13632 
  def __ne__(self, other):
13633 
    return not (self == other)
13634 
 
13635 
class getItemPricingBySource_args:
13636 
  """
13637 
  Attributes:
13638 
   - itemId
13639 
   - sourceId
13640 
  """
13641 
 
13642 
  thrift_spec = (
13643 
    None, # 0
13644 
    (1, TType.I64, 'itemId', None, None, ), # 1
13645 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13646 
  )
13647 
 
13648 
  def __init__(self, itemId=None, sourceId=None,):
13649 
    self.itemId = itemId
13650 
    self.sourceId = sourceId
13651 
 
13652 
  def read(self, iprot):
13653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13655 
      return
13656 
    iprot.readStructBegin()
13657 
    while True:
13658 
      (fname, ftype, fid) = iprot.readFieldBegin()
13659 
      if ftype == TType.STOP:
13660 
        break
13661 
      if fid == 1:
13662 
        if ftype == TType.I64:
13663 
          self.itemId = iprot.readI64();
13664 
        else:
13665 
          iprot.skip(ftype)
13666 
      elif fid == 2:
13667 
        if ftype == TType.I64:
13668 
          self.sourceId = iprot.readI64();
13669 
        else:
13670 
          iprot.skip(ftype)
13671 
      else:
13672 
        iprot.skip(ftype)
13673 
      iprot.readFieldEnd()
13674 
    iprot.readStructEnd()
13675 
 
13676 
  def write(self, oprot):
13677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13679 
      return
13680 
    oprot.writeStructBegin('getItemPricingBySource_args')
13681 
    if self.itemId is not None:
13682 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13683 
      oprot.writeI64(self.itemId)
13684 
      oprot.writeFieldEnd()
13685 
    if self.sourceId is not None:
13686 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13687 
      oprot.writeI64(self.sourceId)
13688 
      oprot.writeFieldEnd()
13689 
    oprot.writeFieldStop()
13690 
    oprot.writeStructEnd()
13691 
 
13692 
  def validate(self):
13693 
    return
13694 
 
13695 
 
13696 
  def __repr__(self):
13697 
    L = ['%s=%r' % (key, value)
13698 
      for key, value in self.__dict__.iteritems()]
13699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13700 
 
13701 
  def __eq__(self, other):
13702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13703 
 
13704 
  def __ne__(self, other):
13705 
    return not (self == other)
13706 
 
13707 
class getItemPricingBySource_result:
13708 
  """
13709 
  Attributes:
13710 
   - success
13711 
   - cex
13712 
  """
13713 
 
13714 
  thrift_spec = (
13715 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13716 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13717 
  )
13718 
 
13719 
  def __init__(self, success=None, cex=None,):
13720 
    self.success = success
13721 
    self.cex = cex
13722 
 
13723 
  def read(self, iprot):
13724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13726 
      return
13727 
    iprot.readStructBegin()
13728 
    while True:
13729 
      (fname, ftype, fid) = iprot.readFieldBegin()
13730 
      if ftype == TType.STOP:
13731 
        break
13732 
      if fid == 0:
13733 
        if ftype == TType.STRUCT:
13734 
          self.success = SourceItemPricing()
13735 
          self.success.read(iprot)
13736 
        else:
13737 
          iprot.skip(ftype)
13738 
      elif fid == 1:
13739 
        if ftype == TType.STRUCT:
13740 
          self.cex = CatalogServiceException()
13741 
          self.cex.read(iprot)
13742 
        else:
13743 
          iprot.skip(ftype)
13744 
      else:
13745 
        iprot.skip(ftype)
13746 
      iprot.readFieldEnd()
13747 
    iprot.readStructEnd()
13748 
 
13749 
  def write(self, oprot):
13750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13752 
      return
13753 
    oprot.writeStructBegin('getItemPricingBySource_result')
13754 
    if self.success is not None:
13755 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13756 
      self.success.write(oprot)
13757 
      oprot.writeFieldEnd()
13758 
    if self.cex is not None:
13759 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13760 
      self.cex.write(oprot)
13761 
      oprot.writeFieldEnd()
13762 
    oprot.writeFieldStop()
13763 
    oprot.writeStructEnd()
13764 
 
13765 
  def validate(self):
13766 
    return
13767 
 
13768 
 
13769 
  def __repr__(self):
13770 
    L = ['%s=%r' % (key, value)
13771 
      for key, value in self.__dict__.iteritems()]
13772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13773 
 
13774 
  def __eq__(self, other):
13775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13776 
 
13777 
  def __ne__(self, other):
13778 
    return not (self == other)
13779 
 
13780 
class addSourceItemPricing_args:
13781 
  """
13782 
  Attributes:
13783 
   - sourceItemPricing
13784 
  """
13785 
 
13786 
  thrift_spec = (
13787 
    None, # 0
13788 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13789 
  )
13790 
 
13791 
  def __init__(self, sourceItemPricing=None,):
13792 
    self.sourceItemPricing = sourceItemPricing
13793 
 
13794 
  def read(self, iprot):
13795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13797 
      return
13798 
    iprot.readStructBegin()
13799 
    while True:
13800 
      (fname, ftype, fid) = iprot.readFieldBegin()
13801 
      if ftype == TType.STOP:
13802 
        break
13803 
      if fid == 1:
13804 
        if ftype == TType.STRUCT:
13805 
          self.sourceItemPricing = SourceItemPricing()
13806 
          self.sourceItemPricing.read(iprot)
13807 
        else:
13808 
          iprot.skip(ftype)
13809 
      else:
13810 
        iprot.skip(ftype)
13811 
      iprot.readFieldEnd()
13812 
    iprot.readStructEnd()
13813 
 
13814 
  def write(self, oprot):
13815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13817 
      return
13818 
    oprot.writeStructBegin('addSourceItemPricing_args')
13819 
    if self.sourceItemPricing is not None:
13820 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13821 
      self.sourceItemPricing.write(oprot)
13822 
      oprot.writeFieldEnd()
13823 
    oprot.writeFieldStop()
13824 
    oprot.writeStructEnd()
13825 
 
13826 
  def validate(self):
13827 
    return
13828 
 
13829 
 
13830 
  def __repr__(self):
13831 
    L = ['%s=%r' % (key, value)
13832 
      for key, value in self.__dict__.iteritems()]
13833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13834 
 
13835 
  def __eq__(self, other):
13836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13837 
 
13838 
  def __ne__(self, other):
13839 
    return not (self == other)
13840 
 
13841 
class addSourceItemPricing_result:
13842 
  """
13843 
  Attributes:
13844 
   - cex
13845 
  """
13846 
 
13847 
  thrift_spec = (
13848 
    None, # 0
13849 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13850 
  )
13851 
 
13852 
  def __init__(self, cex=None,):
13853 
    self.cex = cex
13854 
 
13855 
  def read(self, iprot):
13856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13858 
      return
13859 
    iprot.readStructBegin()
13860 
    while True:
13861 
      (fname, ftype, fid) = iprot.readFieldBegin()
13862 
      if ftype == TType.STOP:
13863 
        break
13864 
      if fid == 1:
13865 
        if ftype == TType.STRUCT:
13866 
          self.cex = CatalogServiceException()
13867 
          self.cex.read(iprot)
13868 
        else:
13869 
          iprot.skip(ftype)
13870 
      else:
13871 
        iprot.skip(ftype)
13872 
      iprot.readFieldEnd()
13873 
    iprot.readStructEnd()
13874 
 
13875 
  def write(self, oprot):
13876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13878 
      return
13879 
    oprot.writeStructBegin('addSourceItemPricing_result')
13880 
    if self.cex is not None:
13881 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13882 
      self.cex.write(oprot)
13883 
      oprot.writeFieldEnd()
13884 
    oprot.writeFieldStop()
13885 
    oprot.writeStructEnd()
13886 
 
13887 
  def validate(self):
13888 
    return
13889 
 
13890 
 
13891 
  def __repr__(self):
13892 
    L = ['%s=%r' % (key, value)
13893 
      for key, value in self.__dict__.iteritems()]
13894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13895 
 
13896 
  def __eq__(self, other):
13897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13898 
 
13899 
  def __ne__(self, other):
13900 
    return not (self == other)
13901 
 
13902 
class getAllSourcePricing_args:
13903 
  """
13904 
  Attributes:
13905 
   - itemId
13906 
  """
13907 
 
13908 
  thrift_spec = (
13909 
    None, # 0
13910 
    (1, TType.I64, 'itemId', None, None, ), # 1
13911 
  )
13912 
 
13913 
  def __init__(self, itemId=None,):
13914 
    self.itemId = itemId
13915 
 
13916 
  def read(self, iprot):
13917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13919 
      return
13920 
    iprot.readStructBegin()
13921 
    while True:
13922 
      (fname, ftype, fid) = iprot.readFieldBegin()
13923 
      if ftype == TType.STOP:
13924 
        break
13925 
      if fid == 1:
13926 
        if ftype == TType.I64:
13927 
          self.itemId = iprot.readI64();
13928 
        else:
13929 
          iprot.skip(ftype)
13930 
      else:
13931 
        iprot.skip(ftype)
13932 
      iprot.readFieldEnd()
13933 
    iprot.readStructEnd()
13934 
 
13935 
  def write(self, oprot):
13936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13938 
      return
13939 
    oprot.writeStructBegin('getAllSourcePricing_args')
13940 
    if self.itemId is not None:
13941 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13942 
      oprot.writeI64(self.itemId)
13943 
      oprot.writeFieldEnd()
13944 
    oprot.writeFieldStop()
13945 
    oprot.writeStructEnd()
13946 
 
13947 
  def validate(self):
13948 
    return
13949 
 
13950 
 
13951 
  def __repr__(self):
13952 
    L = ['%s=%r' % (key, value)
13953 
      for key, value in self.__dict__.iteritems()]
13954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13955 
 
13956 
  def __eq__(self, other):
13957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13958 
 
13959 
  def __ne__(self, other):
13960 
    return not (self == other)
13961 
 
13962 
class getAllSourcePricing_result:
13963 
  """
13964 
  Attributes:
13965 
   - success
13966 
   - cex
13967 
  """
13968 
 
13969 
  thrift_spec = (
13970 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13971 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13972 
  )
13973 
 
13974 
  def __init__(self, success=None, cex=None,):
13975 
    self.success = success
13976 
    self.cex = cex
13977 
 
13978 
  def read(self, iprot):
13979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13981 
      return
13982 
    iprot.readStructBegin()
13983 
    while True:
13984 
      (fname, ftype, fid) = iprot.readFieldBegin()
13985 
      if ftype == TType.STOP:
13986 
        break
13987 
      if fid == 0:
13988 
        if ftype == TType.LIST:
13989 
          self.success = []
7438 amit.gupta 13990 
          (_etype247, _size244) = iprot.readListBegin()
13991 
          for _i248 in xrange(_size244):
13992 
            _elem249 = SourceItemPricing()
13993 
            _elem249.read(iprot)
13994 
            self.success.append(_elem249)
5944 mandeep.dh 13995 
          iprot.readListEnd()
13996 
        else:
13997 
          iprot.skip(ftype)
13998 
      elif fid == 1:
13999 
        if ftype == TType.STRUCT:
14000 
          self.cex = CatalogServiceException()
14001 
          self.cex.read(iprot)
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      else:
14005 
        iprot.skip(ftype)
14006 
      iprot.readFieldEnd()
14007 
    iprot.readStructEnd()
14008 
 
14009 
  def write(self, oprot):
14010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14012 
      return
14013 
    oprot.writeStructBegin('getAllSourcePricing_result')
14014 
    if self.success is not None:
14015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14017 
      for iter250 in self.success:
14018 
        iter250.write(oprot)
5944 mandeep.dh 14019 
      oprot.writeListEnd()
14020 
      oprot.writeFieldEnd()
14021 
    if self.cex is not None:
14022 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14023 
      self.cex.write(oprot)
14024 
      oprot.writeFieldEnd()
14025 
    oprot.writeFieldStop()
14026 
    oprot.writeStructEnd()
14027 
 
14028 
  def validate(self):
14029 
    return
14030 
 
14031 
 
14032 
  def __repr__(self):
14033 
    L = ['%s=%r' % (key, value)
14034 
      for key, value in self.__dict__.iteritems()]
14035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14036 
 
14037 
  def __eq__(self, other):
14038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14039 
 
14040 
  def __ne__(self, other):
14041 
    return not (self == other)
14042 
 
14043 
class getItemForSource_args:
14044 
  """
14045 
  Attributes:
14046 
   - item_id
14047 
   - sourceId
14048 
  """
14049 
 
14050 
  thrift_spec = (
14051 
    None, # 0
14052 
    (1, TType.I64, 'item_id', None, None, ), # 1
14053 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14054 
  )
14055 
 
14056 
  def __init__(self, item_id=None, sourceId=None,):
14057 
    self.item_id = item_id
14058 
    self.sourceId = sourceId
14059 
 
14060 
  def read(self, iprot):
14061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14063 
      return
14064 
    iprot.readStructBegin()
14065 
    while True:
14066 
      (fname, ftype, fid) = iprot.readFieldBegin()
14067 
      if ftype == TType.STOP:
14068 
        break
14069 
      if fid == 1:
14070 
        if ftype == TType.I64:
14071 
          self.item_id = iprot.readI64();
14072 
        else:
14073 
          iprot.skip(ftype)
14074 
      elif fid == 2:
14075 
        if ftype == TType.I64:
14076 
          self.sourceId = iprot.readI64();
14077 
        else:
14078 
          iprot.skip(ftype)
14079 
      else:
14080 
        iprot.skip(ftype)
14081 
      iprot.readFieldEnd()
14082 
    iprot.readStructEnd()
14083 
 
14084 
  def write(self, oprot):
14085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14087 
      return
14088 
    oprot.writeStructBegin('getItemForSource_args')
14089 
    if self.item_id is not None:
14090 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14091 
      oprot.writeI64(self.item_id)
14092 
      oprot.writeFieldEnd()
14093 
    if self.sourceId is not None:
14094 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14095 
      oprot.writeI64(self.sourceId)
14096 
      oprot.writeFieldEnd()
14097 
    oprot.writeFieldStop()
14098 
    oprot.writeStructEnd()
14099 
 
14100 
  def validate(self):
14101 
    return
14102 
 
14103 
 
14104 
  def __repr__(self):
14105 
    L = ['%s=%r' % (key, value)
14106 
      for key, value in self.__dict__.iteritems()]
14107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14108 
 
14109 
  def __eq__(self, other):
14110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14111 
 
14112 
  def __ne__(self, other):
14113 
    return not (self == other)
14114 
 
14115 
class getItemForSource_result:
14116 
  """
14117 
  Attributes:
14118 
   - success
14119 
   - cex
14120 
  """
14121 
 
14122 
  thrift_spec = (
14123 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
14124 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14125 
  )
14126 
 
14127 
  def __init__(self, success=None, cex=None,):
14128 
    self.success = success
14129 
    self.cex = cex
14130 
 
14131 
  def read(self, iprot):
14132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14134 
      return
14135 
    iprot.readStructBegin()
14136 
    while True:
14137 
      (fname, ftype, fid) = iprot.readFieldBegin()
14138 
      if ftype == TType.STOP:
14139 
        break
14140 
      if fid == 0:
14141 
        if ftype == TType.STRUCT:
14142 
          self.success = Item()
14143 
          self.success.read(iprot)
14144 
        else:
14145 
          iprot.skip(ftype)
14146 
      elif fid == 1:
14147 
        if ftype == TType.STRUCT:
14148 
          self.cex = CatalogServiceException()
14149 
          self.cex.read(iprot)
14150 
        else:
14151 
          iprot.skip(ftype)
14152 
      else:
14153 
        iprot.skip(ftype)
14154 
      iprot.readFieldEnd()
14155 
    iprot.readStructEnd()
14156 
 
14157 
  def write(self, oprot):
14158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14160 
      return
14161 
    oprot.writeStructBegin('getItemForSource_result')
14162 
    if self.success is not None:
14163 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14164 
      self.success.write(oprot)
14165 
      oprot.writeFieldEnd()
14166 
    if self.cex is not None:
14167 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14168 
      self.cex.write(oprot)
14169 
      oprot.writeFieldEnd()
14170 
    oprot.writeFieldStop()
14171 
    oprot.writeStructEnd()
14172 
 
14173 
  def validate(self):
14174 
    return
14175 
 
14176 
 
14177 
  def __repr__(self):
14178 
    L = ['%s=%r' % (key, value)
14179 
      for key, value in self.__dict__.iteritems()]
14180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14181 
 
14182 
  def __eq__(self, other):
14183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14184 
 
14185 
  def __ne__(self, other):
14186 
    return not (self == other)
14187 
 
14188 
class searchItemsInRange_args:
14189 
  """
14190 
  Attributes:
14191 
   - searchTerms
14192 
   - offset
14193 
   - limit
14194 
  """
14195 
 
14196 
  thrift_spec = (
14197 
    None, # 0
14198 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14199 
    (2, TType.I64, 'offset', None, None, ), # 2
14200 
    (3, TType.I64, 'limit', None, None, ), # 3
14201 
  )
14202 
 
14203 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
14204 
    self.searchTerms = searchTerms
14205 
    self.offset = offset
14206 
    self.limit = limit
14207 
 
14208 
  def read(self, iprot):
14209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14211 
      return
14212 
    iprot.readStructBegin()
14213 
    while True:
14214 
      (fname, ftype, fid) = iprot.readFieldBegin()
14215 
      if ftype == TType.STOP:
14216 
        break
14217 
      if fid == 1:
14218 
        if ftype == TType.LIST:
14219 
          self.searchTerms = []
7438 amit.gupta 14220 
          (_etype254, _size251) = iprot.readListBegin()
14221 
          for _i255 in xrange(_size251):
14222 
            _elem256 = iprot.readString();
14223 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 14224 
          iprot.readListEnd()
14225 
        else:
14226 
          iprot.skip(ftype)
14227 
      elif fid == 2:
14228 
        if ftype == TType.I64:
14229 
          self.offset = iprot.readI64();
14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      elif fid == 3:
14233 
        if ftype == TType.I64:
14234 
          self.limit = iprot.readI64();
14235 
        else:
14236 
          iprot.skip(ftype)
14237 
      else:
14238 
        iprot.skip(ftype)
14239 
      iprot.readFieldEnd()
14240 
    iprot.readStructEnd()
14241 
 
14242 
  def write(self, oprot):
14243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14245 
      return
14246 
    oprot.writeStructBegin('searchItemsInRange_args')
14247 
    if self.searchTerms is not None:
14248 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14249 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14250 
      for iter257 in self.searchTerms:
14251 
        oprot.writeString(iter257)
5944 mandeep.dh 14252 
      oprot.writeListEnd()
14253 
      oprot.writeFieldEnd()
14254 
    if self.offset is not None:
14255 
      oprot.writeFieldBegin('offset', TType.I64, 2)
14256 
      oprot.writeI64(self.offset)
14257 
      oprot.writeFieldEnd()
14258 
    if self.limit is not None:
14259 
      oprot.writeFieldBegin('limit', TType.I64, 3)
14260 
      oprot.writeI64(self.limit)
14261 
      oprot.writeFieldEnd()
14262 
    oprot.writeFieldStop()
14263 
    oprot.writeStructEnd()
14264 
 
14265 
  def validate(self):
14266 
    return
14267 
 
14268 
 
14269 
  def __repr__(self):
14270 
    L = ['%s=%r' % (key, value)
14271 
      for key, value in self.__dict__.iteritems()]
14272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14273 
 
14274 
  def __eq__(self, other):
14275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14276 
 
14277 
  def __ne__(self, other):
14278 
    return not (self == other)
14279 
 
14280 
class searchItemsInRange_result:
14281 
  """
14282 
  Attributes:
14283 
   - success
14284 
  """
14285 
 
14286 
  thrift_spec = (
14287 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14288 
  )
14289 
 
14290 
  def __init__(self, success=None,):
14291 
    self.success = success
14292 
 
14293 
  def read(self, iprot):
14294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14296 
      return
14297 
    iprot.readStructBegin()
14298 
    while True:
14299 
      (fname, ftype, fid) = iprot.readFieldBegin()
14300 
      if ftype == TType.STOP:
14301 
        break
14302 
      if fid == 0:
14303 
        if ftype == TType.LIST:
14304 
          self.success = []
7438 amit.gupta 14305 
          (_etype261, _size258) = iprot.readListBegin()
14306 
          for _i262 in xrange(_size258):
14307 
            _elem263 = Item()
14308 
            _elem263.read(iprot)
14309 
            self.success.append(_elem263)
5944 mandeep.dh 14310 
          iprot.readListEnd()
14311 
        else:
14312 
          iprot.skip(ftype)
14313 
      else:
14314 
        iprot.skip(ftype)
14315 
      iprot.readFieldEnd()
14316 
    iprot.readStructEnd()
14317 
 
14318 
  def write(self, oprot):
14319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14321 
      return
14322 
    oprot.writeStructBegin('searchItemsInRange_result')
14323 
    if self.success is not None:
14324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14326 
      for iter264 in self.success:
14327 
        iter264.write(oprot)
5944 mandeep.dh 14328 
      oprot.writeListEnd()
14329 
      oprot.writeFieldEnd()
14330 
    oprot.writeFieldStop()
14331 
    oprot.writeStructEnd()
14332 
 
14333 
  def validate(self):
14334 
    return
14335 
 
14336 
 
14337 
  def __repr__(self):
14338 
    L = ['%s=%r' % (key, value)
14339 
      for key, value in self.__dict__.iteritems()]
14340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14341 
 
14342 
  def __eq__(self, other):
14343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14344 
 
14345 
  def __ne__(self, other):
14346 
    return not (self == other)
14347 
 
14348 
class getSearchResultCount_args:
14349 
  """
14350 
  Attributes:
14351 
   - searchTerms
14352 
  """
14353 
 
14354 
  thrift_spec = (
14355 
    None, # 0
14356 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14357 
  )
14358 
 
14359 
  def __init__(self, searchTerms=None,):
14360 
    self.searchTerms = searchTerms
14361 
 
14362 
  def read(self, iprot):
14363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14365 
      return
14366 
    iprot.readStructBegin()
14367 
    while True:
14368 
      (fname, ftype, fid) = iprot.readFieldBegin()
14369 
      if ftype == TType.STOP:
14370 
        break
14371 
      if fid == 1:
14372 
        if ftype == TType.LIST:
14373 
          self.searchTerms = []
7438 amit.gupta 14374 
          (_etype268, _size265) = iprot.readListBegin()
14375 
          for _i269 in xrange(_size265):
14376 
            _elem270 = iprot.readString();
14377 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14378 
          iprot.readListEnd()
14379 
        else:
14380 
          iprot.skip(ftype)
14381 
      else:
14382 
        iprot.skip(ftype)
14383 
      iprot.readFieldEnd()
14384 
    iprot.readStructEnd()
14385 
 
14386 
  def write(self, oprot):
14387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14389 
      return
14390 
    oprot.writeStructBegin('getSearchResultCount_args')
14391 
    if self.searchTerms is not None:
14392 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14393 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14394 
      for iter271 in self.searchTerms:
14395 
        oprot.writeString(iter271)
5944 mandeep.dh 14396 
      oprot.writeListEnd()
14397 
      oprot.writeFieldEnd()
14398 
    oprot.writeFieldStop()
14399 
    oprot.writeStructEnd()
14400 
 
14401 
  def validate(self):
14402 
    return
14403 
 
14404 
 
14405 
  def __repr__(self):
14406 
    L = ['%s=%r' % (key, value)
14407 
      for key, value in self.__dict__.iteritems()]
14408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14409 
 
14410 
  def __eq__(self, other):
14411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14412 
 
14413 
  def __ne__(self, other):
14414 
    return not (self == other)
14415 
 
14416 
class getSearchResultCount_result:
14417 
  """
14418 
  Attributes:
14419 
   - success
14420 
  """
14421 
 
14422 
  thrift_spec = (
14423 
    (0, TType.I32, 'success', None, None, ), # 0
14424 
  )
14425 
 
14426 
  def __init__(self, success=None,):
14427 
    self.success = success
14428 
 
14429 
  def read(self, iprot):
14430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14432 
      return
14433 
    iprot.readStructBegin()
14434 
    while True:
14435 
      (fname, ftype, fid) = iprot.readFieldBegin()
14436 
      if ftype == TType.STOP:
14437 
        break
14438 
      if fid == 0:
14439 
        if ftype == TType.I32:
14440 
          self.success = iprot.readI32();
14441 
        else:
14442 
          iprot.skip(ftype)
14443 
      else:
14444 
        iprot.skip(ftype)
14445 
      iprot.readFieldEnd()
14446 
    iprot.readStructEnd()
14447 
 
14448 
  def write(self, oprot):
14449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14451 
      return
14452 
    oprot.writeStructBegin('getSearchResultCount_result')
14453 
    if self.success is not None:
14454 
      oprot.writeFieldBegin('success', TType.I32, 0)
14455 
      oprot.writeI32(self.success)
14456 
      oprot.writeFieldEnd()
14457 
    oprot.writeFieldStop()
14458 
    oprot.writeStructEnd()
14459 
 
14460 
  def validate(self):
14461 
    return
14462 
 
14463 
 
14464 
  def __repr__(self):
14465 
    L = ['%s=%r' % (key, value)
14466 
      for key, value in self.__dict__.iteritems()]
14467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14468 
 
14469 
  def __eq__(self, other):
14470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14471 
 
14472 
  def __ne__(self, other):
14473 
    return not (self == other)
14474 
 
14475 
class getProductNotifications_args:
14476 
  """
14477 
  Attributes:
14478 
   - startDateTime
14479 
  """
14480 
 
14481 
  thrift_spec = (
14482 
    None, # 0
14483 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14484 
  )
14485 
 
14486 
  def __init__(self, startDateTime=None,):
14487 
    self.startDateTime = startDateTime
14488 
 
14489 
  def read(self, iprot):
14490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14492 
      return
14493 
    iprot.readStructBegin()
14494 
    while True:
14495 
      (fname, ftype, fid) = iprot.readFieldBegin()
14496 
      if ftype == TType.STOP:
14497 
        break
14498 
      if fid == 1:
14499 
        if ftype == TType.I64:
14500 
          self.startDateTime = iprot.readI64();
14501 
        else:
14502 
          iprot.skip(ftype)
14503 
      else:
14504 
        iprot.skip(ftype)
14505 
      iprot.readFieldEnd()
14506 
    iprot.readStructEnd()
14507 
 
14508 
  def write(self, oprot):
14509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14511 
      return
14512 
    oprot.writeStructBegin('getProductNotifications_args')
14513 
    if self.startDateTime is not None:
14514 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14515 
      oprot.writeI64(self.startDateTime)
14516 
      oprot.writeFieldEnd()
14517 
    oprot.writeFieldStop()
14518 
    oprot.writeStructEnd()
14519 
 
14520 
  def validate(self):
14521 
    return
14522 
 
14523 
 
14524 
  def __repr__(self):
14525 
    L = ['%s=%r' % (key, value)
14526 
      for key, value in self.__dict__.iteritems()]
14527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14528 
 
14529 
  def __eq__(self, other):
14530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14531 
 
14532 
  def __ne__(self, other):
14533 
    return not (self == other)
14534 
 
14535 
class getProductNotifications_result:
14536 
  """
14537 
  Attributes:
14538 
   - success
14539 
  """
14540 
 
14541 
  thrift_spec = (
14542 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14543 
  )
14544 
 
14545 
  def __init__(self, success=None,):
14546 
    self.success = success
14547 
 
14548 
  def read(self, iprot):
14549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14551 
      return
14552 
    iprot.readStructBegin()
14553 
    while True:
14554 
      (fname, ftype, fid) = iprot.readFieldBegin()
14555 
      if ftype == TType.STOP:
14556 
        break
14557 
      if fid == 0:
14558 
        if ftype == TType.LIST:
14559 
          self.success = []
7438 amit.gupta 14560 
          (_etype275, _size272) = iprot.readListBegin()
14561 
          for _i276 in xrange(_size272):
14562 
            _elem277 = ProductNotificationRequest()
14563 
            _elem277.read(iprot)
14564 
            self.success.append(_elem277)
5944 mandeep.dh 14565 
          iprot.readListEnd()
14566 
        else:
14567 
          iprot.skip(ftype)
14568 
      else:
14569 
        iprot.skip(ftype)
14570 
      iprot.readFieldEnd()
14571 
    iprot.readStructEnd()
14572 
 
14573 
  def write(self, oprot):
14574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14576 
      return
14577 
    oprot.writeStructBegin('getProductNotifications_result')
14578 
    if self.success is not None:
14579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14581 
      for iter278 in self.success:
14582 
        iter278.write(oprot)
5944 mandeep.dh 14583 
      oprot.writeListEnd()
14584 
      oprot.writeFieldEnd()
14585 
    oprot.writeFieldStop()
14586 
    oprot.writeStructEnd()
14587 
 
14588 
  def validate(self):
14589 
    return
14590 
 
14591 
 
14592 
  def __repr__(self):
14593 
    L = ['%s=%r' % (key, value)
14594 
      for key, value in self.__dict__.iteritems()]
14595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14596 
 
14597 
  def __eq__(self, other):
14598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14599 
 
14600 
  def __ne__(self, other):
14601 
    return not (self == other)
14602 
 
14603 
class getProductNotificationRequestCount_args:
14604 
  """
14605 
  Attributes:
14606 
   - startDateTime
7897 amar.kumar 14607 
   - categoryId
5944 mandeep.dh 14608 
  """
14609 
 
14610 
  thrift_spec = (
14611 
    None, # 0
14612 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 14613 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 14614 
  )
14615 
 
7897 amar.kumar 14616 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 14617 
    self.startDateTime = startDateTime
7897 amar.kumar 14618 
    self.categoryId = categoryId
5944 mandeep.dh 14619 
 
14620 
  def read(self, iprot):
14621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14623 
      return
14624 
    iprot.readStructBegin()
14625 
    while True:
14626 
      (fname, ftype, fid) = iprot.readFieldBegin()
14627 
      if ftype == TType.STOP:
14628 
        break
14629 
      if fid == 1:
14630 
        if ftype == TType.I64:
14631 
          self.startDateTime = iprot.readI64();
14632 
        else:
14633 
          iprot.skip(ftype)
7897 amar.kumar 14634 
      elif fid == 2:
14635 
        if ftype == TType.I64:
14636 
          self.categoryId = iprot.readI64();
14637 
        else:
14638 
          iprot.skip(ftype)
5944 mandeep.dh 14639 
      else:
14640 
        iprot.skip(ftype)
14641 
      iprot.readFieldEnd()
14642 
    iprot.readStructEnd()
14643 
 
14644 
  def write(self, oprot):
14645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14647 
      return
14648 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14649 
    if self.startDateTime is not None:
14650 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14651 
      oprot.writeI64(self.startDateTime)
14652 
      oprot.writeFieldEnd()
7897 amar.kumar 14653 
    if self.categoryId is not None:
14654 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
14655 
      oprot.writeI64(self.categoryId)
14656 
      oprot.writeFieldEnd()
5944 mandeep.dh 14657 
    oprot.writeFieldStop()
14658 
    oprot.writeStructEnd()
14659 
 
14660 
  def validate(self):
14661 
    return
14662 
 
14663 
 
14664 
  def __repr__(self):
14665 
    L = ['%s=%r' % (key, value)
14666 
      for key, value in self.__dict__.iteritems()]
14667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14668 
 
14669 
  def __eq__(self, other):
14670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14671 
 
14672 
  def __ne__(self, other):
14673 
    return not (self == other)
14674 
 
14675 
class getProductNotificationRequestCount_result:
14676 
  """
14677 
  Attributes:
14678 
   - success
14679 
  """
14680 
 
14681 
  thrift_spec = (
14682 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14683 
  )
14684 
 
14685 
  def __init__(self, success=None,):
14686 
    self.success = success
14687 
 
14688 
  def read(self, iprot):
14689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14691 
      return
14692 
    iprot.readStructBegin()
14693 
    while True:
14694 
      (fname, ftype, fid) = iprot.readFieldBegin()
14695 
      if ftype == TType.STOP:
14696 
        break
14697 
      if fid == 0:
14698 
        if ftype == TType.LIST:
14699 
          self.success = []
7438 amit.gupta 14700 
          (_etype282, _size279) = iprot.readListBegin()
14701 
          for _i283 in xrange(_size279):
14702 
            _elem284 = ProductNotificationRequestCount()
14703 
            _elem284.read(iprot)
14704 
            self.success.append(_elem284)
5944 mandeep.dh 14705 
          iprot.readListEnd()
14706 
        else:
14707 
          iprot.skip(ftype)
14708 
      else:
14709 
        iprot.skip(ftype)
14710 
      iprot.readFieldEnd()
14711 
    iprot.readStructEnd()
14712 
 
14713 
  def write(self, oprot):
14714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14716 
      return
14717 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14718 
    if self.success is not None:
14719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14720 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14721 
      for iter285 in self.success:
14722 
        iter285.write(oprot)
5944 mandeep.dh 14723 
      oprot.writeListEnd()
14724 
      oprot.writeFieldEnd()
14725 
    oprot.writeFieldStop()
14726 
    oprot.writeStructEnd()
14727 
 
14728 
  def validate(self):
14729 
    return
14730 
 
14731 
 
14732 
  def __repr__(self):
14733 
    L = ['%s=%r' % (key, value)
14734 
      for key, value in self.__dict__.iteritems()]
14735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14736 
 
14737 
  def __eq__(self, other):
14738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14739 
 
14740 
  def __ne__(self, other):
14741 
    return not (self == other)
14742 
 
14743 
class addAuthorizationLog_args:
14744 
  """
14745 
  Attributes:
14746 
   - itemId
14747 
   - username
14748 
   - reason
14749 
  """
14750 
 
14751 
  thrift_spec = (
14752 
    None, # 0
14753 
    (1, TType.I64, 'itemId', None, None, ), # 1
14754 
    (2, TType.STRING, 'username', None, None, ), # 2
14755 
    (3, TType.STRING, 'reason', None, None, ), # 3
14756 
  )
14757 
 
14758 
  def __init__(self, itemId=None, username=None, reason=None,):
14759 
    self.itemId = itemId
14760 
    self.username = username
14761 
    self.reason = reason
14762 
 
14763 
  def read(self, iprot):
14764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14766 
      return
14767 
    iprot.readStructBegin()
14768 
    while True:
14769 
      (fname, ftype, fid) = iprot.readFieldBegin()
14770 
      if ftype == TType.STOP:
14771 
        break
14772 
      if fid == 1:
14773 
        if ftype == TType.I64:
14774 
          self.itemId = iprot.readI64();
14775 
        else:
14776 
          iprot.skip(ftype)
14777 
      elif fid == 2:
14778 
        if ftype == TType.STRING:
14779 
          self.username = iprot.readString();
14780 
        else:
14781 
          iprot.skip(ftype)
14782 
      elif fid == 3:
14783 
        if ftype == TType.STRING:
14784 
          self.reason = iprot.readString();
14785 
        else:
14786 
          iprot.skip(ftype)
14787 
      else:
14788 
        iprot.skip(ftype)
14789 
      iprot.readFieldEnd()
14790 
    iprot.readStructEnd()
14791 
 
14792 
  def write(self, oprot):
14793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14795 
      return
14796 
    oprot.writeStructBegin('addAuthorizationLog_args')
14797 
    if self.itemId is not None:
14798 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14799 
      oprot.writeI64(self.itemId)
14800 
      oprot.writeFieldEnd()
14801 
    if self.username is not None:
14802 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14803 
      oprot.writeString(self.username)
14804 
      oprot.writeFieldEnd()
14805 
    if self.reason is not None:
14806 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14807 
      oprot.writeString(self.reason)
14808 
      oprot.writeFieldEnd()
14809 
    oprot.writeFieldStop()
14810 
    oprot.writeStructEnd()
14811 
 
14812 
  def validate(self):
14813 
    return
14814 
 
14815 
 
14816 
  def __repr__(self):
14817 
    L = ['%s=%r' % (key, value)
14818 
      for key, value in self.__dict__.iteritems()]
14819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14820 
 
14821 
  def __eq__(self, other):
14822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14823 
 
14824 
  def __ne__(self, other):
14825 
    return not (self == other)
14826 
 
14827 
class addAuthorizationLog_result:
14828 
  """
14829 
  Attributes:
14830 
   - success
14831 
   - cex
14832 
  """
14833 
 
14834 
  thrift_spec = (
14835 
    (0, TType.BOOL, 'success', None, None, ), # 0
14836 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14837 
  )
14838 
 
14839 
  def __init__(self, success=None, cex=None,):
14840 
    self.success = success
14841 
    self.cex = cex
14842 
 
14843 
  def read(self, iprot):
14844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14846 
      return
14847 
    iprot.readStructBegin()
14848 
    while True:
14849 
      (fname, ftype, fid) = iprot.readFieldBegin()
14850 
      if ftype == TType.STOP:
14851 
        break
14852 
      if fid == 0:
14853 
        if ftype == TType.BOOL:
14854 
          self.success = iprot.readBool();
14855 
        else:
14856 
          iprot.skip(ftype)
14857 
      elif fid == 1:
14858 
        if ftype == TType.STRUCT:
14859 
          self.cex = CatalogServiceException()
14860 
          self.cex.read(iprot)
14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
14872 
    oprot.writeStructBegin('addAuthorizationLog_result')
14873 
    if self.success is not None:
14874 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14875 
      oprot.writeBool(self.success)
14876 
      oprot.writeFieldEnd()
14877 
    if self.cex is not None:
14878 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14879 
      self.cex.write(oprot)
14880 
      oprot.writeFieldEnd()
14881 
    oprot.writeFieldStop()
14882 
    oprot.writeStructEnd()
14883 
 
14884 
  def validate(self):
14885 
    return
14886 
 
14887 
 
14888 
  def __repr__(self):
14889 
    L = ['%s=%r' % (key, value)
14890 
      for key, value in self.__dict__.iteritems()]
14891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14892 
 
14893 
  def __eq__(self, other):
14894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14895 
 
14896 
  def __ne__(self, other):
14897 
    return not (self == other)
14898 
 
14899 
class addupdateVoucherForItem_args:
14900 
  """
14901 
  Attributes:
14902 
   - catalog_item_id
14903 
   - voucherType
14904 
   - voucherAmount
14905 
  """
14906 
 
14907 
  thrift_spec = (
14908 
    None, # 0
14909 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14910 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14911 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14912 
  )
14913 
 
14914 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14915 
    self.catalog_item_id = catalog_item_id
14916 
    self.voucherType = voucherType
14917 
    self.voucherAmount = voucherAmount
14918 
 
14919 
  def read(self, iprot):
14920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14922 
      return
14923 
    iprot.readStructBegin()
14924 
    while True:
14925 
      (fname, ftype, fid) = iprot.readFieldBegin()
14926 
      if ftype == TType.STOP:
14927 
        break
14928 
      if fid == 1:
14929 
        if ftype == TType.I64:
14930 
          self.catalog_item_id = iprot.readI64();
14931 
        else:
14932 
          iprot.skip(ftype)
14933 
      elif fid == 2:
14934 
        if ftype == TType.I64:
14935 
          self.voucherType = iprot.readI64();
14936 
        else:
14937 
          iprot.skip(ftype)
14938 
      elif fid == 3:
14939 
        if ftype == TType.I64:
14940 
          self.voucherAmount = iprot.readI64();
14941 
        else:
14942 
          iprot.skip(ftype)
14943 
      else:
14944 
        iprot.skip(ftype)
14945 
      iprot.readFieldEnd()
14946 
    iprot.readStructEnd()
14947 
 
14948 
  def write(self, oprot):
14949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14951 
      return
14952 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14953 
    if self.catalog_item_id is not None:
14954 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14955 
      oprot.writeI64(self.catalog_item_id)
14956 
      oprot.writeFieldEnd()
14957 
    if self.voucherType is not None:
14958 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14959 
      oprot.writeI64(self.voucherType)
14960 
      oprot.writeFieldEnd()
14961 
    if self.voucherAmount is not None:
14962 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14963 
      oprot.writeI64(self.voucherAmount)
14964 
      oprot.writeFieldEnd()
14965 
    oprot.writeFieldStop()
14966 
    oprot.writeStructEnd()
14967 
 
14968 
  def validate(self):
14969 
    return
14970 
 
14971 
 
14972 
  def __repr__(self):
14973 
    L = ['%s=%r' % (key, value)
14974 
      for key, value in self.__dict__.iteritems()]
14975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14976 
 
14977 
  def __eq__(self, other):
14978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14979 
 
14980 
  def __ne__(self, other):
14981 
    return not (self == other)
14982 
 
14983 
class addupdateVoucherForItem_result:
14984 
  """
14985 
  Attributes:
14986 
   - success
14987 
   - cex
14988 
  """
14989 
 
14990 
  thrift_spec = (
14991 
    (0, TType.BOOL, 'success', None, None, ), # 0
14992 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14993 
  )
14994 
 
14995 
  def __init__(self, success=None, cex=None,):
14996 
    self.success = success
14997 
    self.cex = cex
14998 
 
14999 
  def read(self, iprot):
15000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15002 
      return
15003 
    iprot.readStructBegin()
15004 
    while True:
15005 
      (fname, ftype, fid) = iprot.readFieldBegin()
15006 
      if ftype == TType.STOP:
15007 
        break
15008 
      if fid == 0:
15009 
        if ftype == TType.BOOL:
15010 
          self.success = iprot.readBool();
15011 
        else:
15012 
          iprot.skip(ftype)
15013 
      elif fid == 1:
15014 
        if ftype == TType.STRUCT:
15015 
          self.cex = CatalogServiceException()
15016 
          self.cex.read(iprot)
15017 
        else:
15018 
          iprot.skip(ftype)
15019 
      else:
15020 
        iprot.skip(ftype)
15021 
      iprot.readFieldEnd()
15022 
    iprot.readStructEnd()
15023 
 
15024 
  def write(self, oprot):
15025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15027 
      return
15028 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
15029 
    if self.success is not None:
15030 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15031 
      oprot.writeBool(self.success)
15032 
      oprot.writeFieldEnd()
15033 
    if self.cex is not None:
15034 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15035 
      self.cex.write(oprot)
15036 
      oprot.writeFieldEnd()
15037 
    oprot.writeFieldStop()
15038 
    oprot.writeStructEnd()
15039 
 
15040 
  def validate(self):
15041 
    return
15042 
 
15043 
 
15044 
  def __repr__(self):
15045 
    L = ['%s=%r' % (key, value)
15046 
      for key, value in self.__dict__.iteritems()]
15047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15048 
 
15049 
  def __eq__(self, other):
15050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15051 
 
15052 
  def __ne__(self, other):
15053 
    return not (self == other)
15054 
 
15055 
class deleteVoucherForItem_args:
15056 
  """
15057 
  Attributes:
15058 
   - catalog_item_id
15059 
   - voucherType
15060 
  """
15061 
 
15062 
  thrift_spec = (
15063 
    None, # 0
15064 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15065 
    (2, TType.I64, 'voucherType', None, None, ), # 2
15066 
  )
15067 
 
15068 
  def __init__(self, catalog_item_id=None, voucherType=None,):
15069 
    self.catalog_item_id = catalog_item_id
15070 
    self.voucherType = voucherType
15071 
 
15072 
  def read(self, iprot):
15073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15075 
      return
15076 
    iprot.readStructBegin()
15077 
    while True:
15078 
      (fname, ftype, fid) = iprot.readFieldBegin()
15079 
      if ftype == TType.STOP:
15080 
        break
15081 
      if fid == 1:
15082 
        if ftype == TType.I64:
15083 
          self.catalog_item_id = iprot.readI64();
15084 
        else:
15085 
          iprot.skip(ftype)
15086 
      elif fid == 2:
15087 
        if ftype == TType.I64:
15088 
          self.voucherType = iprot.readI64();
15089 
        else:
15090 
          iprot.skip(ftype)
15091 
      else:
15092 
        iprot.skip(ftype)
15093 
      iprot.readFieldEnd()
15094 
    iprot.readStructEnd()
15095 
 
15096 
  def write(self, oprot):
15097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15099 
      return
15100 
    oprot.writeStructBegin('deleteVoucherForItem_args')
15101 
    if self.catalog_item_id is not None:
15102 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15103 
      oprot.writeI64(self.catalog_item_id)
15104 
      oprot.writeFieldEnd()
15105 
    if self.voucherType is not None:
15106 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15107 
      oprot.writeI64(self.voucherType)
15108 
      oprot.writeFieldEnd()
15109 
    oprot.writeFieldStop()
15110 
    oprot.writeStructEnd()
15111 
 
15112 
  def validate(self):
15113 
    return
15114 
 
15115 
 
15116 
  def __repr__(self):
15117 
    L = ['%s=%r' % (key, value)
15118 
      for key, value in self.__dict__.iteritems()]
15119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15120 
 
15121 
  def __eq__(self, other):
15122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15123 
 
15124 
  def __ne__(self, other):
15125 
    return not (self == other)
15126 
 
15127 
class deleteVoucherForItem_result:
15128 
  """
15129 
  Attributes:
15130 
   - success
15131 
   - cex
15132 
  """
15133 
 
15134 
  thrift_spec = (
15135 
    (0, TType.BOOL, 'success', None, None, ), # 0
15136 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15137 
  )
15138 
 
15139 
  def __init__(self, success=None, cex=None,):
15140 
    self.success = success
15141 
    self.cex = cex
15142 
 
15143 
  def read(self, iprot):
15144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15146 
      return
15147 
    iprot.readStructBegin()
15148 
    while True:
15149 
      (fname, ftype, fid) = iprot.readFieldBegin()
15150 
      if ftype == TType.STOP:
15151 
        break
15152 
      if fid == 0:
15153 
        if ftype == TType.BOOL:
15154 
          self.success = iprot.readBool();
15155 
        else:
15156 
          iprot.skip(ftype)
15157 
      elif fid == 1:
15158 
        if ftype == TType.STRUCT:
15159 
          self.cex = CatalogServiceException()
15160 
          self.cex.read(iprot)
15161 
        else:
15162 
          iprot.skip(ftype)
15163 
      else:
15164 
        iprot.skip(ftype)
15165 
      iprot.readFieldEnd()
15166 
    iprot.readStructEnd()
15167 
 
15168 
  def write(self, oprot):
15169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15171 
      return
15172 
    oprot.writeStructBegin('deleteVoucherForItem_result')
15173 
    if self.success is not None:
15174 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15175 
      oprot.writeBool(self.success)
15176 
      oprot.writeFieldEnd()
15177 
    if self.cex is not None:
15178 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15179 
      self.cex.write(oprot)
15180 
      oprot.writeFieldEnd()
15181 
    oprot.writeFieldStop()
15182 
    oprot.writeStructEnd()
15183 
 
15184 
  def validate(self):
15185 
    return
15186 
 
15187 
 
15188 
  def __repr__(self):
15189 
    L = ['%s=%r' % (key, value)
15190 
      for key, value in self.__dict__.iteritems()]
15191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15192 
 
15193 
  def __eq__(self, other):
15194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15195 
 
15196 
  def __ne__(self, other):
15197 
    return not (self == other)
15198 
 
15199 
class getVoucherAmount_args:
15200 
  """
15201 
  Attributes:
15202 
   - itemId
15203 
   - voucherType
15204 
  """
15205 
 
15206 
  thrift_spec = (
15207 
    None, # 0
15208 
    (1, TType.I64, 'itemId', None, None, ), # 1
15209 
    (2, TType.I64, 'voucherType', None, None, ), # 2
15210 
  )
15211 
 
15212 
  def __init__(self, itemId=None, voucherType=None,):
15213 
    self.itemId = itemId
15214 
    self.voucherType = voucherType
15215 
 
15216 
  def read(self, iprot):
15217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15219 
      return
15220 
    iprot.readStructBegin()
15221 
    while True:
15222 
      (fname, ftype, fid) = iprot.readFieldBegin()
15223 
      if ftype == TType.STOP:
15224 
        break
15225 
      if fid == 1:
15226 
        if ftype == TType.I64:
15227 
          self.itemId = iprot.readI64();
15228 
        else:
15229 
          iprot.skip(ftype)
15230 
      elif fid == 2:
15231 
        if ftype == TType.I64:
15232 
          self.voucherType = iprot.readI64();
15233 
        else:
15234 
          iprot.skip(ftype)
15235 
      else:
15236 
        iprot.skip(ftype)
15237 
      iprot.readFieldEnd()
15238 
    iprot.readStructEnd()
15239 
 
15240 
  def write(self, oprot):
15241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15243 
      return
15244 
    oprot.writeStructBegin('getVoucherAmount_args')
15245 
    if self.itemId is not None:
15246 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15247 
      oprot.writeI64(self.itemId)
15248 
      oprot.writeFieldEnd()
15249 
    if self.voucherType is not None:
15250 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15251 
      oprot.writeI64(self.voucherType)
15252 
      oprot.writeFieldEnd()
15253 
    oprot.writeFieldStop()
15254 
    oprot.writeStructEnd()
15255 
 
15256 
  def validate(self):
15257 
    return
15258 
 
15259 
 
15260 
  def __repr__(self):
15261 
    L = ['%s=%r' % (key, value)
15262 
      for key, value in self.__dict__.iteritems()]
15263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15264 
 
15265 
  def __eq__(self, other):
15266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15267 
 
15268 
  def __ne__(self, other):
15269 
    return not (self == other)
15270 
 
15271 
class getVoucherAmount_result:
15272 
  """
15273 
  Attributes:
15274 
   - success
15275 
  """
15276 
 
15277 
  thrift_spec = (
15278 
    (0, TType.I64, 'success', None, None, ), # 0
15279 
  )
15280 
 
15281 
  def __init__(self, success=None,):
15282 
    self.success = success
15283 
 
15284 
  def read(self, iprot):
15285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15287 
      return
15288 
    iprot.readStructBegin()
15289 
    while True:
15290 
      (fname, ftype, fid) = iprot.readFieldBegin()
15291 
      if ftype == TType.STOP:
15292 
        break
15293 
      if fid == 0:
15294 
        if ftype == TType.I64:
15295 
          self.success = iprot.readI64();
15296 
        else:
15297 
          iprot.skip(ftype)
15298 
      else:
15299 
        iprot.skip(ftype)
15300 
      iprot.readFieldEnd()
15301 
    iprot.readStructEnd()
15302 
 
15303 
  def write(self, oprot):
15304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15306 
      return
15307 
    oprot.writeStructBegin('getVoucherAmount_result')
15308 
    if self.success is not None:
15309 
      oprot.writeFieldBegin('success', TType.I64, 0)
15310 
      oprot.writeI64(self.success)
15311 
      oprot.writeFieldEnd()
15312 
    oprot.writeFieldStop()
15313 
    oprot.writeStructEnd()
15314 
 
15315 
  def validate(self):
15316 
    return
15317 
 
15318 
 
15319 
  def __repr__(self):
15320 
    L = ['%s=%r' % (key, value)
15321 
      for key, value in self.__dict__.iteritems()]
15322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15323 
 
15324 
  def __eq__(self, other):
15325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15326 
 
15327 
  def __ne__(self, other):
15328 
    return not (self == other)
15329 
 
15330 
class getAllItemVouchers_args:
15331 
  """
15332 
  Attributes:
15333 
   - itemId
15334 
  """
15335 
 
15336 
  thrift_spec = (
15337 
    None, # 0
15338 
    (1, TType.I64, 'itemId', None, None, ), # 1
15339 
  )
15340 
 
15341 
  def __init__(self, itemId=None,):
15342 
    self.itemId = itemId
15343 
 
15344 
  def read(self, iprot):
15345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15347 
      return
15348 
    iprot.readStructBegin()
15349 
    while True:
15350 
      (fname, ftype, fid) = iprot.readFieldBegin()
15351 
      if ftype == TType.STOP:
15352 
        break
15353 
      if fid == 1:
15354 
        if ftype == TType.I64:
15355 
          self.itemId = iprot.readI64();
15356 
        else:
15357 
          iprot.skip(ftype)
15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('getAllItemVouchers_args')
15368 
    if self.itemId is not None:
15369 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15370 
      oprot.writeI64(self.itemId)
15371 
      oprot.writeFieldEnd()
15372 
    oprot.writeFieldStop()
15373 
    oprot.writeStructEnd()
15374 
 
15375 
  def validate(self):
15376 
    return
15377 
 
15378 
 
15379 
  def __repr__(self):
15380 
    L = ['%s=%r' % (key, value)
15381 
      for key, value in self.__dict__.iteritems()]
15382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15383 
 
15384 
  def __eq__(self, other):
15385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15386 
 
15387 
  def __ne__(self, other):
15388 
    return not (self == other)
15389 
 
15390 
class getAllItemVouchers_result:
15391 
  """
15392 
  Attributes:
15393 
   - success
15394 
  """
15395 
 
15396 
  thrift_spec = (
15397 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15398 
  )
15399 
 
15400 
  def __init__(self, success=None,):
15401 
    self.success = success
15402 
 
15403 
  def read(self, iprot):
15404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15406 
      return
15407 
    iprot.readStructBegin()
15408 
    while True:
15409 
      (fname, ftype, fid) = iprot.readFieldBegin()
15410 
      if ftype == TType.STOP:
15411 
        break
15412 
      if fid == 0:
15413 
        if ftype == TType.LIST:
15414 
          self.success = []
7438 amit.gupta 15415 
          (_etype289, _size286) = iprot.readListBegin()
15416 
          for _i290 in xrange(_size286):
15417 
            _elem291 = VoucherItemMapping()
15418 
            _elem291.read(iprot)
15419 
            self.success.append(_elem291)
5944 mandeep.dh 15420 
          iprot.readListEnd()
15421 
        else:
15422 
          iprot.skip(ftype)
15423 
      else:
15424 
        iprot.skip(ftype)
15425 
      iprot.readFieldEnd()
15426 
    iprot.readStructEnd()
15427 
 
15428 
  def write(self, oprot):
15429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15431 
      return
15432 
    oprot.writeStructBegin('getAllItemVouchers_result')
15433 
    if self.success is not None:
15434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15436 
      for iter292 in self.success:
15437 
        iter292.write(oprot)
5944 mandeep.dh 15438 
      oprot.writeListEnd()
15439 
      oprot.writeFieldEnd()
15440 
    oprot.writeFieldStop()
15441 
    oprot.writeStructEnd()
15442 
 
15443 
  def validate(self):
15444 
    return
15445 
 
15446 
 
15447 
  def __repr__(self):
15448 
    L = ['%s=%r' % (key, value)
15449 
      for key, value in self.__dict__.iteritems()]
15450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15451 
 
15452 
  def __eq__(self, other):
15453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15454 
 
15455 
  def __ne__(self, other):
15456 
    return not (self == other)
15457 
 
15458 
class isValidCatalogItemId_args:
15459 
  """
15460 
  Attributes:
15461 
   - catalog_item_id
15462 
  """
15463 
 
15464 
  thrift_spec = (
15465 
    None, # 0
15466 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15467 
  )
15468 
 
15469 
  def __init__(self, catalog_item_id=None,):
15470 
    self.catalog_item_id = catalog_item_id
15471 
 
15472 
  def read(self, iprot):
15473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15475 
      return
15476 
    iprot.readStructBegin()
15477 
    while True:
15478 
      (fname, ftype, fid) = iprot.readFieldBegin()
15479 
      if ftype == TType.STOP:
15480 
        break
15481 
      if fid == 1:
15482 
        if ftype == TType.I64:
15483 
          self.catalog_item_id = iprot.readI64();
15484 
        else:
15485 
          iprot.skip(ftype)
15486 
      else:
15487 
        iprot.skip(ftype)
15488 
      iprot.readFieldEnd()
15489 
    iprot.readStructEnd()
15490 
 
15491 
  def write(self, oprot):
15492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15494 
      return
15495 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15496 
    if self.catalog_item_id is not None:
15497 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15498 
      oprot.writeI64(self.catalog_item_id)
15499 
      oprot.writeFieldEnd()
15500 
    oprot.writeFieldStop()
15501 
    oprot.writeStructEnd()
15502 
 
15503 
  def validate(self):
15504 
    return
15505 
 
15506 
 
15507 
  def __repr__(self):
15508 
    L = ['%s=%r' % (key, value)
15509 
      for key, value in self.__dict__.iteritems()]
15510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15511 
 
15512 
  def __eq__(self, other):
15513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15514 
 
15515 
  def __ne__(self, other):
15516 
    return not (self == other)
15517 
 
15518 
class isValidCatalogItemId_result:
15519 
  """
15520 
  Attributes:
15521 
   - success
15522 
  """
15523 
 
15524 
  thrift_spec = (
15525 
    (0, TType.BOOL, 'success', None, None, ), # 0
15526 
  )
15527 
 
15528 
  def __init__(self, success=None,):
15529 
    self.success = success
15530 
 
15531 
  def read(self, iprot):
15532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15534 
      return
15535 
    iprot.readStructBegin()
15536 
    while True:
15537 
      (fname, ftype, fid) = iprot.readFieldBegin()
15538 
      if ftype == TType.STOP:
15539 
        break
15540 
      if fid == 0:
15541 
        if ftype == TType.BOOL:
15542 
          self.success = iprot.readBool();
15543 
        else:
15544 
          iprot.skip(ftype)
15545 
      else:
15546 
        iprot.skip(ftype)
15547 
      iprot.readFieldEnd()
15548 
    iprot.readStructEnd()
15549 
 
15550 
  def write(self, oprot):
15551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15553 
      return
15554 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15555 
    if self.success is not None:
15556 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15557 
      oprot.writeBool(self.success)
15558 
      oprot.writeFieldEnd()
15559 
    oprot.writeFieldStop()
15560 
    oprot.writeStructEnd()
15561 
 
15562 
  def validate(self):
15563 
    return
15564 
 
15565 
 
15566 
  def __repr__(self):
15567 
    L = ['%s=%r' % (key, value)
15568 
      for key, value in self.__dict__.iteritems()]
15569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15570 
 
15571 
  def __eq__(self, other):
15572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15573 
 
15574 
  def __ne__(self, other):
15575 
    return not (self == other)
6039 amit.gupta 15576 
 
15577 
class getVatPercentageForItem_args:
15578 
  """
15579 
  Attributes:
15580 
   - itemId
7330 amit.gupta 15581 
   - stateId
6039 amit.gupta 15582 
   - price
15583 
  """
15584 
 
15585 
  thrift_spec = (
15586 
    None, # 0
15587 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15588 
    (2, TType.I64, 'stateId', None, None, ), # 2
15589 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15590 
  )
15591 
 
7330 amit.gupta 15592 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15593 
    self.itemId = itemId
7330 amit.gupta 15594 
    self.stateId = stateId
6039 amit.gupta 15595 
    self.price = price
15596 
 
15597 
  def read(self, iprot):
15598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15600 
      return
15601 
    iprot.readStructBegin()
15602 
    while True:
15603 
      (fname, ftype, fid) = iprot.readFieldBegin()
15604 
      if ftype == TType.STOP:
15605 
        break
15606 
      if fid == 1:
15607 
        if ftype == TType.I64:
15608 
          self.itemId = iprot.readI64();
15609 
        else:
15610 
          iprot.skip(ftype)
15611 
      elif fid == 2:
7330 amit.gupta 15612 
        if ftype == TType.I64:
15613 
          self.stateId = iprot.readI64();
15614 
        else:
15615 
          iprot.skip(ftype)
15616 
      elif fid == 3:
6039 amit.gupta 15617 
        if ftype == TType.DOUBLE:
15618 
          self.price = iprot.readDouble();
15619 
        else:
15620 
          iprot.skip(ftype)
15621 
      else:
15622 
        iprot.skip(ftype)
15623 
      iprot.readFieldEnd()
15624 
    iprot.readStructEnd()
15625 
 
15626 
  def write(self, oprot):
15627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15629 
      return
15630 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15631 
    if self.itemId is not None:
15632 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15633 
      oprot.writeI64(self.itemId)
15634 
      oprot.writeFieldEnd()
7330 amit.gupta 15635 
    if self.stateId is not None:
15636 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15637 
      oprot.writeI64(self.stateId)
15638 
      oprot.writeFieldEnd()
6039 amit.gupta 15639 
    if self.price is not None:
7330 amit.gupta 15640 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15641 
      oprot.writeDouble(self.price)
15642 
      oprot.writeFieldEnd()
15643 
    oprot.writeFieldStop()
15644 
    oprot.writeStructEnd()
15645 
 
15646 
  def validate(self):
15647 
    return
15648 
 
15649 
 
15650 
  def __repr__(self):
15651 
    L = ['%s=%r' % (key, value)
15652 
      for key, value in self.__dict__.iteritems()]
15653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15654 
 
15655 
  def __eq__(self, other):
15656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15657 
 
15658 
  def __ne__(self, other):
15659 
    return not (self == other)
15660 
 
15661 
class getVatPercentageForItem_result:
15662 
  """
15663 
  Attributes:
15664 
   - success
7340 amit.gupta 15665 
   - cex
6039 amit.gupta 15666 
  """
15667 
 
15668 
  thrift_spec = (
15669 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15670 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15671 
  )
15672 
 
7340 amit.gupta 15673 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15674 
    self.success = success
7340 amit.gupta 15675 
    self.cex = cex
6039 amit.gupta 15676 
 
15677 
  def read(self, iprot):
15678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15680 
      return
15681 
    iprot.readStructBegin()
15682 
    while True:
15683 
      (fname, ftype, fid) = iprot.readFieldBegin()
15684 
      if ftype == TType.STOP:
15685 
        break
15686 
      if fid == 0:
15687 
        if ftype == TType.DOUBLE:
15688 
          self.success = iprot.readDouble();
15689 
        else:
15690 
          iprot.skip(ftype)
7340 amit.gupta 15691 
      elif fid == 1:
15692 
        if ftype == TType.STRUCT:
15693 
          self.cex = CatalogServiceException()
15694 
          self.cex.read(iprot)
15695 
        else:
15696 
          iprot.skip(ftype)
6039 amit.gupta 15697 
      else:
15698 
        iprot.skip(ftype)
15699 
      iprot.readFieldEnd()
15700 
    iprot.readStructEnd()
15701 
 
15702 
  def write(self, oprot):
15703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15705 
      return
15706 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15707 
    if self.success is not None:
15708 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15709 
      oprot.writeDouble(self.success)
15710 
      oprot.writeFieldEnd()
7340 amit.gupta 15711 
    if self.cex is not None:
15712 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15713 
      self.cex.write(oprot)
15714 
      oprot.writeFieldEnd()
6039 amit.gupta 15715 
    oprot.writeFieldStop()
15716 
    oprot.writeStructEnd()
15717 
 
15718 
  def validate(self):
15719 
    return
15720 
 
15721 
 
15722 
  def __repr__(self):
15723 
    L = ['%s=%r' % (key, value)
15724 
      for key, value in self.__dict__.iteritems()]
15725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15726 
 
15727 
  def __eq__(self, other):
15728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15729 
 
15730 
  def __ne__(self, other):
15731 
    return not (self == other)
15732 
 
15733 
class getVatAmountForItem_args:
15734 
  """
15735 
  Attributes:
15736 
   - itemId
15737 
   - price
15738 
  """
15739 
 
15740 
  thrift_spec = (
15741 
    None, # 0
15742 
    (1, TType.I64, 'itemId', None, None, ), # 1
15743 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15744 
  )
15745 
 
15746 
  def __init__(self, itemId=None, price=None,):
15747 
    self.itemId = itemId
15748 
    self.price = price
15749 
 
15750 
  def read(self, iprot):
15751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15753 
      return
15754 
    iprot.readStructBegin()
15755 
    while True:
15756 
      (fname, ftype, fid) = iprot.readFieldBegin()
15757 
      if ftype == TType.STOP:
15758 
        break
15759 
      if fid == 1:
15760 
        if ftype == TType.I64:
15761 
          self.itemId = iprot.readI64();
15762 
        else:
15763 
          iprot.skip(ftype)
15764 
      elif fid == 2:
15765 
        if ftype == TType.DOUBLE:
15766 
          self.price = iprot.readDouble();
15767 
        else:
15768 
          iprot.skip(ftype)
15769 
      else:
15770 
        iprot.skip(ftype)
15771 
      iprot.readFieldEnd()
15772 
    iprot.readStructEnd()
15773 
 
15774 
  def write(self, oprot):
15775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15777 
      return
15778 
    oprot.writeStructBegin('getVatAmountForItem_args')
15779 
    if self.itemId is not None:
15780 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15781 
      oprot.writeI64(self.itemId)
15782 
      oprot.writeFieldEnd()
15783 
    if self.price is not None:
15784 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15785 
      oprot.writeDouble(self.price)
15786 
      oprot.writeFieldEnd()
15787 
    oprot.writeFieldStop()
15788 
    oprot.writeStructEnd()
15789 
 
15790 
  def validate(self):
15791 
    return
15792 
 
15793 
 
15794 
  def __repr__(self):
15795 
    L = ['%s=%r' % (key, value)
15796 
      for key, value in self.__dict__.iteritems()]
15797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15798 
 
15799 
  def __eq__(self, other):
15800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15801 
 
15802 
  def __ne__(self, other):
15803 
    return not (self == other)
15804 
 
15805 
class getVatAmountForItem_result:
15806 
  """
15807 
  Attributes:
15808 
   - success
15809 
  """
15810 
 
15811 
  thrift_spec = (
15812 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15813 
  )
15814 
 
15815 
  def __init__(self, success=None,):
15816 
    self.success = success
15817 
 
15818 
  def read(self, iprot):
15819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15821 
      return
15822 
    iprot.readStructBegin()
15823 
    while True:
15824 
      (fname, ftype, fid) = iprot.readFieldBegin()
15825 
      if ftype == TType.STOP:
15826 
        break
15827 
      if fid == 0:
15828 
        if ftype == TType.DOUBLE:
15829 
          self.success = iprot.readDouble();
15830 
        else:
15831 
          iprot.skip(ftype)
15832 
      else:
15833 
        iprot.skip(ftype)
15834 
      iprot.readFieldEnd()
15835 
    iprot.readStructEnd()
15836 
 
15837 
  def write(self, oprot):
15838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15840 
      return
15841 
    oprot.writeStructBegin('getVatAmountForItem_result')
15842 
    if self.success is not None:
15843 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15844 
      oprot.writeDouble(self.success)
15845 
      oprot.writeFieldEnd()
15846 
    oprot.writeFieldStop()
15847 
    oprot.writeStructEnd()
15848 
 
15849 
  def validate(self):
15850 
    return
15851 
 
15852 
 
15853 
  def __repr__(self):
15854 
    L = ['%s=%r' % (key, value)
15855 
      for key, value in self.__dict__.iteritems()]
15856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15857 
 
15858 
  def __eq__(self, other):
15859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15860 
 
15861 
  def __ne__(self, other):
15862 
    return not (self == other)
6531 vikram.rag 15863 
 
15864 
class getAllIgnoredInventoryUpdateItemsList_args:
15865 
  """
15866 
  Attributes:
15867 
   - offset
15868 
   - limit
15869 
  """
15870 
 
15871 
  thrift_spec = (
15872 
    None, # 0
15873 
    (1, TType.I32, 'offset', None, None, ), # 1
15874 
    (2, TType.I32, 'limit', None, None, ), # 2
15875 
  )
15876 
 
15877 
  def __init__(self, offset=None, limit=None,):
15878 
    self.offset = offset
15879 
    self.limit = limit
15880 
 
15881 
  def read(self, iprot):
15882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15884 
      return
15885 
    iprot.readStructBegin()
15886 
    while True:
15887 
      (fname, ftype, fid) = iprot.readFieldBegin()
15888 
      if ftype == TType.STOP:
15889 
        break
15890 
      if fid == 1:
15891 
        if ftype == TType.I32:
15892 
          self.offset = iprot.readI32();
15893 
        else:
15894 
          iprot.skip(ftype)
15895 
      elif fid == 2:
15896 
        if ftype == TType.I32:
15897 
          self.limit = iprot.readI32();
15898 
        else:
15899 
          iprot.skip(ftype)
15900 
      else:
15901 
        iprot.skip(ftype)
15902 
      iprot.readFieldEnd()
15903 
    iprot.readStructEnd()
15904 
 
15905 
  def write(self, oprot):
15906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15908 
      return
15909 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15910 
    if self.offset is not None:
15911 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15912 
      oprot.writeI32(self.offset)
15913 
      oprot.writeFieldEnd()
15914 
    if self.limit is not None:
15915 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15916 
      oprot.writeI32(self.limit)
15917 
      oprot.writeFieldEnd()
15918 
    oprot.writeFieldStop()
15919 
    oprot.writeStructEnd()
15920 
 
15921 
  def validate(self):
15922 
    return
15923 
 
15924 
 
15925 
  def __repr__(self):
15926 
    L = ['%s=%r' % (key, value)
15927 
      for key, value in self.__dict__.iteritems()]
15928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15929 
 
15930 
  def __eq__(self, other):
15931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15932 
 
15933 
  def __ne__(self, other):
15934 
    return not (self == other)
15935 
 
15936 
class getAllIgnoredInventoryUpdateItemsList_result:
15937 
  """
15938 
  Attributes:
15939 
   - success
15940 
  """
15941 
 
15942 
  thrift_spec = (
15943 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15944 
  )
15945 
 
15946 
  def __init__(self, success=None,):
15947 
    self.success = success
15948 
 
15949 
  def read(self, iprot):
15950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15952 
      return
15953 
    iprot.readStructBegin()
15954 
    while True:
15955 
      (fname, ftype, fid) = iprot.readFieldBegin()
15956 
      if ftype == TType.STOP:
15957 
        break
15958 
      if fid == 0:
15959 
        if ftype == TType.LIST:
15960 
          self.success = []
7438 amit.gupta 15961 
          (_etype296, _size293) = iprot.readListBegin()
15962 
          for _i297 in xrange(_size293):
15963 
            _elem298 = Item()
15964 
            _elem298.read(iprot)
15965 
            self.success.append(_elem298)
6531 vikram.rag 15966 
          iprot.readListEnd()
15967 
        else:
15968 
          iprot.skip(ftype)
15969 
      else:
15970 
        iprot.skip(ftype)
15971 
      iprot.readFieldEnd()
15972 
    iprot.readStructEnd()
15973 
 
15974 
  def write(self, oprot):
15975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15977 
      return
15978 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15979 
    if self.success is not None:
15980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15981 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15982 
      for iter299 in self.success:
15983 
        iter299.write(oprot)
6531 vikram.rag 15984 
      oprot.writeListEnd()
15985 
      oprot.writeFieldEnd()
15986 
    oprot.writeFieldStop()
15987 
    oprot.writeStructEnd()
15988 
 
15989 
  def validate(self):
15990 
    return
15991 
 
15992 
 
15993 
  def __repr__(self):
15994 
    L = ['%s=%r' % (key, value)
15995 
      for key, value in self.__dict__.iteritems()]
15996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15997 
 
15998 
  def __eq__(self, other):
15999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16000 
 
16001 
  def __ne__(self, other):
16002 
    return not (self == other)
6805 anupam.sin 16003 
 
6821 amar.kumar 16004 
class getAllAliveItems_args:
16005 
 
16006 
  thrift_spec = (
16007 
  )
16008 
 
16009 
  def read(self, iprot):
16010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16012 
      return
16013 
    iprot.readStructBegin()
16014 
    while True:
16015 
      (fname, ftype, fid) = iprot.readFieldBegin()
16016 
      if ftype == TType.STOP:
16017 
        break
16018 
      else:
16019 
        iprot.skip(ftype)
16020 
      iprot.readFieldEnd()
16021 
    iprot.readStructEnd()
16022 
 
16023 
  def write(self, oprot):
16024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16026 
      return
16027 
    oprot.writeStructBegin('getAllAliveItems_args')
16028 
    oprot.writeFieldStop()
16029 
    oprot.writeStructEnd()
16030 
 
16031 
  def validate(self):
16032 
    return
16033 
 
16034 
 
16035 
  def __repr__(self):
16036 
    L = ['%s=%r' % (key, value)
16037 
      for key, value in self.__dict__.iteritems()]
16038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16039 
 
16040 
  def __eq__(self, other):
16041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16042 
 
16043 
  def __ne__(self, other):
16044 
    return not (self == other)
16045 
 
16046 
class getAllAliveItems_result:
16047 
  """
16048 
  Attributes:
16049 
   - success
16050 
  """
16051 
 
16052 
  thrift_spec = (
16053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16054 
  )
16055 
 
16056 
  def __init__(self, success=None,):
16057 
    self.success = success
16058 
 
16059 
  def read(self, iprot):
16060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16062 
      return
16063 
    iprot.readStructBegin()
16064 
    while True:
16065 
      (fname, ftype, fid) = iprot.readFieldBegin()
16066 
      if ftype == TType.STOP:
16067 
        break
16068 
      if fid == 0:
16069 
        if ftype == TType.LIST:
16070 
          self.success = []
7438 amit.gupta 16071 
          (_etype303, _size300) = iprot.readListBegin()
16072 
          for _i304 in xrange(_size300):
16073 
            _elem305 = Item()
16074 
            _elem305.read(iprot)
16075 
            self.success.append(_elem305)
6821 amar.kumar 16076 
          iprot.readListEnd()
16077 
        else:
16078 
          iprot.skip(ftype)
16079 
      else:
16080 
        iprot.skip(ftype)
16081 
      iprot.readFieldEnd()
16082 
    iprot.readStructEnd()
16083 
 
16084 
  def write(self, oprot):
16085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16087 
      return
16088 
    oprot.writeStructBegin('getAllAliveItems_result')
16089 
    if self.success is not None:
16090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16091 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16092 
      for iter306 in self.success:
16093 
        iter306.write(oprot)
6821 amar.kumar 16094 
      oprot.writeListEnd()
16095 
      oprot.writeFieldEnd()
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 
 
6805 anupam.sin 16114 
class getInsuranceAmount_args:
16115 
  """
16116 
  Attributes:
16117 
   - itemId
6921 anupam.sin 16118 
   - price
6805 anupam.sin 16119 
   - insurerId
16120 
   - quantity
16121 
  """
16122 
 
16123 
  thrift_spec = (
16124 
    None, # 0
16125 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 16126 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
16127 
    (3, TType.I64, 'insurerId', None, None, ), # 3
16128 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 16129 
  )
16130 
 
6921 anupam.sin 16131 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 16132 
    self.itemId = itemId
6921 anupam.sin 16133 
    self.price = price
6805 anupam.sin 16134 
    self.insurerId = insurerId
16135 
    self.quantity = quantity
16136 
 
16137 
  def read(self, iprot):
16138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16140 
      return
16141 
    iprot.readStructBegin()
16142 
    while True:
16143 
      (fname, ftype, fid) = iprot.readFieldBegin()
16144 
      if ftype == TType.STOP:
16145 
        break
16146 
      if fid == 1:
16147 
        if ftype == TType.I64:
16148 
          self.itemId = iprot.readI64();
16149 
        else:
16150 
          iprot.skip(ftype)
16151 
      elif fid == 2:
6921 anupam.sin 16152 
        if ftype == TType.DOUBLE:
16153 
          self.price = iprot.readDouble();
16154 
        else:
16155 
          iprot.skip(ftype)
16156 
      elif fid == 3:
6805 anupam.sin 16157 
        if ftype == TType.I64:
16158 
          self.insurerId = iprot.readI64();
16159 
        else:
16160 
          iprot.skip(ftype)
6921 anupam.sin 16161 
      elif fid == 4:
6805 anupam.sin 16162 
        if ftype == TType.I64:
16163 
          self.quantity = iprot.readI64();
16164 
        else:
16165 
          iprot.skip(ftype)
16166 
      else:
16167 
        iprot.skip(ftype)
16168 
      iprot.readFieldEnd()
16169 
    iprot.readStructEnd()
16170 
 
16171 
  def write(self, oprot):
16172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16174 
      return
16175 
    oprot.writeStructBegin('getInsuranceAmount_args')
16176 
    if self.itemId is not None:
16177 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16178 
      oprot.writeI64(self.itemId)
16179 
      oprot.writeFieldEnd()
6921 anupam.sin 16180 
    if self.price is not None:
16181 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
16182 
      oprot.writeDouble(self.price)
16183 
      oprot.writeFieldEnd()
6805 anupam.sin 16184 
    if self.insurerId is not None:
6921 anupam.sin 16185 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 16186 
      oprot.writeI64(self.insurerId)
16187 
      oprot.writeFieldEnd()
16188 
    if self.quantity is not None:
6921 anupam.sin 16189 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 16190 
      oprot.writeI64(self.quantity)
16191 
      oprot.writeFieldEnd()
16192 
    oprot.writeFieldStop()
16193 
    oprot.writeStructEnd()
16194 
 
16195 
  def validate(self):
16196 
    return
16197 
 
16198 
 
16199 
  def __repr__(self):
16200 
    L = ['%s=%r' % (key, value)
16201 
      for key, value in self.__dict__.iteritems()]
16202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16203 
 
16204 
  def __eq__(self, other):
16205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16206 
 
16207 
  def __ne__(self, other):
16208 
    return not (self == other)
16209 
 
16210 
class getInsuranceAmount_result:
16211 
  """
16212 
  Attributes:
16213 
   - success
16214 
  """
16215 
 
16216 
  thrift_spec = (
16217 
    (0, TType.I64, 'success', None, None, ), # 0
16218 
  )
16219 
 
16220 
  def __init__(self, success=None,):
16221 
    self.success = success
16222 
 
16223 
  def read(self, iprot):
16224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16226 
      return
16227 
    iprot.readStructBegin()
16228 
    while True:
16229 
      (fname, ftype, fid) = iprot.readFieldBegin()
16230 
      if ftype == TType.STOP:
16231 
        break
16232 
      if fid == 0:
16233 
        if ftype == TType.I64:
16234 
          self.success = iprot.readI64();
16235 
        else:
16236 
          iprot.skip(ftype)
16237 
      else:
16238 
        iprot.skip(ftype)
16239 
      iprot.readFieldEnd()
16240 
    iprot.readStructEnd()
16241 
 
16242 
  def write(self, oprot):
16243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16245 
      return
16246 
    oprot.writeStructBegin('getInsuranceAmount_result')
16247 
    if self.success is not None:
16248 
      oprot.writeFieldBegin('success', TType.I64, 0)
16249 
      oprot.writeI64(self.success)
16250 
      oprot.writeFieldEnd()
16251 
    oprot.writeFieldStop()
16252 
    oprot.writeStructEnd()
16253 
 
16254 
  def validate(self):
16255 
    return
16256 
 
16257 
 
16258 
  def __repr__(self):
16259 
    L = ['%s=%r' % (key, value)
16260 
      for key, value in self.__dict__.iteritems()]
16261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16262 
 
16263 
  def __eq__(self, other):
16264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16265 
 
16266 
  def __ne__(self, other):
16267 
    return not (self == other)
16268 
 
16269 
class getInsurer_args:
16270 
  """
16271 
  Attributes:
16272 
   - insurerId
16273 
  """
16274 
 
16275 
  thrift_spec = (
16276 
    None, # 0
16277 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16278 
  )
16279 
 
16280 
  def __init__(self, insurerId=None,):
16281 
    self.insurerId = insurerId
16282 
 
16283 
  def read(self, iprot):
16284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16286 
      return
16287 
    iprot.readStructBegin()
16288 
    while True:
16289 
      (fname, ftype, fid) = iprot.readFieldBegin()
16290 
      if ftype == TType.STOP:
16291 
        break
16292 
      if fid == 1:
16293 
        if ftype == TType.I64:
16294 
          self.insurerId = iprot.readI64();
16295 
        else:
16296 
          iprot.skip(ftype)
16297 
      else:
16298 
        iprot.skip(ftype)
16299 
      iprot.readFieldEnd()
16300 
    iprot.readStructEnd()
16301 
 
16302 
  def write(self, oprot):
16303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16305 
      return
16306 
    oprot.writeStructBegin('getInsurer_args')
16307 
    if self.insurerId is not None:
16308 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16309 
      oprot.writeI64(self.insurerId)
16310 
      oprot.writeFieldEnd()
16311 
    oprot.writeFieldStop()
16312 
    oprot.writeStructEnd()
16313 
 
16314 
  def validate(self):
16315 
    return
16316 
 
16317 
 
16318 
  def __repr__(self):
16319 
    L = ['%s=%r' % (key, value)
16320 
      for key, value in self.__dict__.iteritems()]
16321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16322 
 
16323 
  def __eq__(self, other):
16324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16325 
 
16326 
  def __ne__(self, other):
16327 
    return not (self == other)
16328 
 
16329 
class getInsurer_result:
16330 
  """
16331 
  Attributes:
16332 
   - success
16333 
  """
16334 
 
16335 
  thrift_spec = (
16336 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
16337 
  )
16338 
 
16339 
  def __init__(self, success=None,):
16340 
    self.success = success
16341 
 
16342 
  def read(self, iprot):
16343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16345 
      return
16346 
    iprot.readStructBegin()
16347 
    while True:
16348 
      (fname, ftype, fid) = iprot.readFieldBegin()
16349 
      if ftype == TType.STOP:
16350 
        break
16351 
      if fid == 0:
16352 
        if ftype == TType.STRUCT:
16353 
          self.success = Insurer()
16354 
          self.success.read(iprot)
16355 
        else:
16356 
          iprot.skip(ftype)
16357 
      else:
16358 
        iprot.skip(ftype)
16359 
      iprot.readFieldEnd()
16360 
    iprot.readStructEnd()
16361 
 
16362 
  def write(self, oprot):
16363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16365 
      return
16366 
    oprot.writeStructBegin('getInsurer_result')
16367 
    if self.success is not None:
16368 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16369 
      self.success.write(oprot)
16370 
      oprot.writeFieldEnd()
16371 
    oprot.writeFieldStop()
16372 
    oprot.writeStructEnd()
16373 
 
16374 
  def validate(self):
16375 
    return
16376 
 
16377 
 
16378 
  def __repr__(self):
16379 
    L = ['%s=%r' % (key, value)
16380 
      for key, value in self.__dict__.iteritems()]
16381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16382 
 
16383 
  def __eq__(self, other):
16384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16385 
 
16386 
  def __ne__(self, other):
16387 
    return not (self == other)
6838 vikram.rag 16388 
 
16389 
class getAllInsurers_args:
16390 
 
16391 
  thrift_spec = (
16392 
  )
16393 
 
16394 
  def read(self, iprot):
16395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16397 
      return
16398 
    iprot.readStructBegin()
16399 
    while True:
16400 
      (fname, ftype, fid) = iprot.readFieldBegin()
16401 
      if ftype == TType.STOP:
16402 
        break
16403 
      else:
16404 
        iprot.skip(ftype)
16405 
      iprot.readFieldEnd()
16406 
    iprot.readStructEnd()
16407 
 
16408 
  def write(self, oprot):
16409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16411 
      return
16412 
    oprot.writeStructBegin('getAllInsurers_args')
16413 
    oprot.writeFieldStop()
16414 
    oprot.writeStructEnd()
16415 
 
16416 
  def validate(self):
16417 
    return
16418 
 
16419 
 
16420 
  def __repr__(self):
16421 
    L = ['%s=%r' % (key, value)
16422 
      for key, value in self.__dict__.iteritems()]
16423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16424 
 
16425 
  def __eq__(self, other):
16426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16427 
 
16428 
  def __ne__(self, other):
16429 
    return not (self == other)
16430 
 
16431 
class getAllInsurers_result:
16432 
  """
16433 
  Attributes:
16434 
   - success
16435 
  """
16436 
 
16437 
  thrift_spec = (
16438 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16439 
  )
16440 
 
16441 
  def __init__(self, success=None,):
16442 
    self.success = success
16443 
 
16444 
  def read(self, iprot):
16445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16447 
      return
16448 
    iprot.readStructBegin()
16449 
    while True:
16450 
      (fname, ftype, fid) = iprot.readFieldBegin()
16451 
      if ftype == TType.STOP:
16452 
        break
16453 
      if fid == 0:
16454 
        if ftype == TType.LIST:
16455 
          self.success = []
7438 amit.gupta 16456 
          (_etype310, _size307) = iprot.readListBegin()
16457 
          for _i311 in xrange(_size307):
16458 
            _elem312 = Insurer()
16459 
            _elem312.read(iprot)
16460 
            self.success.append(_elem312)
6838 vikram.rag 16461 
          iprot.readListEnd()
16462 
        else:
16463 
          iprot.skip(ftype)
16464 
      else:
16465 
        iprot.skip(ftype)
16466 
      iprot.readFieldEnd()
16467 
    iprot.readStructEnd()
16468 
 
16469 
  def write(self, oprot):
16470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16472 
      return
16473 
    oprot.writeStructBegin('getAllInsurers_result')
16474 
    if self.success is not None:
16475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16477 
      for iter313 in self.success:
16478 
        iter313.write(oprot)
6838 vikram.rag 16479 
      oprot.writeListEnd()
16480 
      oprot.writeFieldEnd()
16481 
    oprot.writeFieldStop()
16482 
    oprot.writeStructEnd()
16483 
 
16484 
  def validate(self):
16485 
    return
16486 
 
16487 
 
16488 
  def __repr__(self):
16489 
    L = ['%s=%r' % (key, value)
16490 
      for key, value in self.__dict__.iteritems()]
16491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16492 
 
16493 
  def __eq__(self, other):
16494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16495 
 
16496 
  def __ne__(self, other):
16497 
    return not (self == other)
6962 rajveer 16498 
 
16499 
class updateInsuranceDeclaredAmount_args:
16500 
  """
16501 
  Attributes:
16502 
   - insurerId
16503 
   - amount
16504 
  """
16505 
 
16506 
  thrift_spec = (
16507 
    None, # 0
16508 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16509 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16510 
  )
16511 
 
16512 
  def __init__(self, insurerId=None, amount=None,):
16513 
    self.insurerId = insurerId
16514 
    self.amount = amount
16515 
 
16516 
  def read(self, iprot):
16517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16519 
      return
16520 
    iprot.readStructBegin()
16521 
    while True:
16522 
      (fname, ftype, fid) = iprot.readFieldBegin()
16523 
      if ftype == TType.STOP:
16524 
        break
16525 
      if fid == 1:
16526 
        if ftype == TType.I64:
16527 
          self.insurerId = iprot.readI64();
16528 
        else:
16529 
          iprot.skip(ftype)
16530 
      elif fid == 2:
16531 
        if ftype == TType.DOUBLE:
16532 
          self.amount = iprot.readDouble();
16533 
        else:
16534 
          iprot.skip(ftype)
16535 
      else:
16536 
        iprot.skip(ftype)
16537 
      iprot.readFieldEnd()
16538 
    iprot.readStructEnd()
16539 
 
16540 
  def write(self, oprot):
16541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16543 
      return
16544 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16545 
    if self.insurerId is not None:
16546 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16547 
      oprot.writeI64(self.insurerId)
16548 
      oprot.writeFieldEnd()
16549 
    if self.amount is not None:
16550 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16551 
      oprot.writeDouble(self.amount)
16552 
      oprot.writeFieldEnd()
16553 
    oprot.writeFieldStop()
16554 
    oprot.writeStructEnd()
16555 
 
16556 
  def validate(self):
16557 
    return
16558 
 
16559 
 
16560 
  def __repr__(self):
16561 
    L = ['%s=%r' % (key, value)
16562 
      for key, value in self.__dict__.iteritems()]
16563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16564 
 
16565 
  def __eq__(self, other):
16566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16567 
 
16568 
  def __ne__(self, other):
16569 
    return not (self == other)
16570 
 
16571 
class updateInsuranceDeclaredAmount_result:
16572 
 
16573 
  thrift_spec = (
16574 
  )
16575 
 
16576 
  def read(self, iprot):
16577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16579 
      return
16580 
    iprot.readStructBegin()
16581 
    while True:
16582 
      (fname, ftype, fid) = iprot.readFieldBegin()
16583 
      if ftype == TType.STOP:
16584 
        break
16585 
      else:
16586 
        iprot.skip(ftype)
16587 
      iprot.readFieldEnd()
16588 
    iprot.readStructEnd()
16589 
 
16590 
  def write(self, oprot):
16591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16593 
      return
16594 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16595 
    oprot.writeFieldStop()
16596 
    oprot.writeStructEnd()
16597 
 
16598 
  def validate(self):
16599 
    return
16600 
 
16601 
 
16602 
  def __repr__(self):
16603 
    L = ['%s=%r' % (key, value)
16604 
      for key, value in self.__dict__.iteritems()]
16605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16606 
 
16607 
  def __eq__(self, other):
16608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16609 
 
16610 
  def __ne__(self, other):
16611 
    return not (self == other)
7190 amar.kumar 16612 
 
16613 
class getFreebieForItem_args:
16614 
  """
16615 
  Attributes:
16616 
   - itemId
16617 
  """
16618 
 
16619 
  thrift_spec = (
16620 
    None, # 0
16621 
    (1, TType.I64, 'itemId', None, None, ), # 1
16622 
  )
16623 
 
16624 
  def __init__(self, itemId=None,):
16625 
    self.itemId = itemId
16626 
 
16627 
  def read(self, iprot):
16628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16630 
      return
16631 
    iprot.readStructBegin()
16632 
    while True:
16633 
      (fname, ftype, fid) = iprot.readFieldBegin()
16634 
      if ftype == TType.STOP:
16635 
        break
16636 
      if fid == 1:
16637 
        if ftype == TType.I64:
16638 
          self.itemId = iprot.readI64();
16639 
        else:
16640 
          iprot.skip(ftype)
16641 
      else:
16642 
        iprot.skip(ftype)
16643 
      iprot.readFieldEnd()
16644 
    iprot.readStructEnd()
16645 
 
16646 
  def write(self, oprot):
16647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16649 
      return
16650 
    oprot.writeStructBegin('getFreebieForItem_args')
16651 
    if self.itemId is not None:
16652 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16653 
      oprot.writeI64(self.itemId)
16654 
      oprot.writeFieldEnd()
16655 
    oprot.writeFieldStop()
16656 
    oprot.writeStructEnd()
16657 
 
16658 
  def validate(self):
16659 
    return
16660 
 
16661 
 
16662 
  def __repr__(self):
16663 
    L = ['%s=%r' % (key, value)
16664 
      for key, value in self.__dict__.iteritems()]
16665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16666 
 
16667 
  def __eq__(self, other):
16668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16669 
 
16670 
  def __ne__(self, other):
16671 
    return not (self == other)
16672 
 
16673 
class getFreebieForItem_result:
16674 
  """
16675 
  Attributes:
16676 
   - success
16677 
  """
16678 
 
16679 
  thrift_spec = (
16680 
    (0, TType.I64, 'success', None, None, ), # 0
16681 
  )
16682 
 
16683 
  def __init__(self, success=None,):
16684 
    self.success = success
16685 
 
16686 
  def read(self, iprot):
16687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16689 
      return
16690 
    iprot.readStructBegin()
16691 
    while True:
16692 
      (fname, ftype, fid) = iprot.readFieldBegin()
16693 
      if ftype == TType.STOP:
16694 
        break
16695 
      if fid == 0:
16696 
        if ftype == TType.I64:
16697 
          self.success = iprot.readI64();
16698 
        else:
16699 
          iprot.skip(ftype)
16700 
      else:
16701 
        iprot.skip(ftype)
16702 
      iprot.readFieldEnd()
16703 
    iprot.readStructEnd()
16704 
 
16705 
  def write(self, oprot):
16706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16708 
      return
16709 
    oprot.writeStructBegin('getFreebieForItem_result')
16710 
    if self.success is not None:
16711 
      oprot.writeFieldBegin('success', TType.I64, 0)
16712 
      oprot.writeI64(self.success)
16713 
      oprot.writeFieldEnd()
16714 
    oprot.writeFieldStop()
16715 
    oprot.writeStructEnd()
16716 
 
16717 
  def validate(self):
16718 
    return
16719 
 
16720 
 
16721 
  def __repr__(self):
16722 
    L = ['%s=%r' % (key, value)
16723 
      for key, value in self.__dict__.iteritems()]
16724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16725 
 
16726 
  def __eq__(self, other):
16727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16728 
 
16729 
  def __ne__(self, other):
16730 
    return not (self == other)
16731 
 
16732 
class addOrUpdateFreebieForItem_args:
16733 
  """
16734 
  Attributes:
16735 
   - freebieItem
16736 
  """
16737 
 
16738 
  thrift_spec = (
16739 
    None, # 0
16740 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16741 
  )
16742 
 
16743 
  def __init__(self, freebieItem=None,):
16744 
    self.freebieItem = freebieItem
16745 
 
16746 
  def read(self, iprot):
16747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16749 
      return
16750 
    iprot.readStructBegin()
16751 
    while True:
16752 
      (fname, ftype, fid) = iprot.readFieldBegin()
16753 
      if ftype == TType.STOP:
16754 
        break
16755 
      if fid == 1:
16756 
        if ftype == TType.STRUCT:
16757 
          self.freebieItem = FreebieItem()
16758 
          self.freebieItem.read(iprot)
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('addOrUpdateFreebieForItem_args')
16771 
    if self.freebieItem is not None:
16772 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16773 
      self.freebieItem.write(oprot)
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 addOrUpdateFreebieForItem_result:
16794 
 
16795 
  thrift_spec = (
16796 
  )
16797 
 
16798 
  def read(self, iprot):
16799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16801 
      return
16802 
    iprot.readStructBegin()
16803 
    while True:
16804 
      (fname, ftype, fid) = iprot.readFieldBegin()
16805 
      if ftype == TType.STOP:
16806 
        break
16807 
      else:
16808 
        iprot.skip(ftype)
16809 
      iprot.readFieldEnd()
16810 
    iprot.readStructEnd()
16811 
 
16812 
  def write(self, oprot):
16813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16815 
      return
16816 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16817 
    oprot.writeFieldStop()
16818 
    oprot.writeStructEnd()
16819 
 
16820 
  def validate(self):
16821 
    return
16822 
 
16823 
 
16824 
  def __repr__(self):
16825 
    L = ['%s=%r' % (key, value)
16826 
      for key, value in self.__dict__.iteritems()]
16827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16828 
 
16829 
  def __eq__(self, other):
16830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16831 
 
16832 
  def __ne__(self, other):
16833 
    return not (self == other)
7256 rajveer 16834 
 
7272 amit.gupta 16835 
class addOrUpdateBrandInfo_args:
16836 
  """
16837 
  Attributes:
16838 
   - brandInfo
16839 
  """
16840 
 
16841 
  thrift_spec = (
16842 
    None, # 0
16843 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16844 
  )
16845 
 
16846 
  def __init__(self, brandInfo=None,):
16847 
    self.brandInfo = brandInfo
16848 
 
16849 
  def read(self, iprot):
16850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16852 
      return
16853 
    iprot.readStructBegin()
16854 
    while True:
16855 
      (fname, ftype, fid) = iprot.readFieldBegin()
16856 
      if ftype == TType.STOP:
16857 
        break
16858 
      if fid == 1:
16859 
        if ftype == TType.STRUCT:
16860 
          self.brandInfo = BrandInfo()
16861 
          self.brandInfo.read(iprot)
16862 
        else:
16863 
          iprot.skip(ftype)
16864 
      else:
16865 
        iprot.skip(ftype)
16866 
      iprot.readFieldEnd()
16867 
    iprot.readStructEnd()
16868 
 
16869 
  def write(self, oprot):
16870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16872 
      return
16873 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16874 
    if self.brandInfo is not None:
16875 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16876 
      self.brandInfo.write(oprot)
16877 
      oprot.writeFieldEnd()
16878 
    oprot.writeFieldStop()
16879 
    oprot.writeStructEnd()
16880 
 
16881 
  def validate(self):
16882 
    return
16883 
 
16884 
 
16885 
  def __repr__(self):
16886 
    L = ['%s=%r' % (key, value)
16887 
      for key, value in self.__dict__.iteritems()]
16888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16889 
 
16890 
  def __eq__(self, other):
16891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16892 
 
16893 
  def __ne__(self, other):
16894 
    return not (self == other)
16895 
 
16896 
class addOrUpdateBrandInfo_result:
16897 
 
16898 
  thrift_spec = (
16899 
  )
16900 
 
16901 
  def read(self, iprot):
16902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16904 
      return
16905 
    iprot.readStructBegin()
16906 
    while True:
16907 
      (fname, ftype, fid) = iprot.readFieldBegin()
16908 
      if ftype == TType.STOP:
16909 
        break
16910 
      else:
16911 
        iprot.skip(ftype)
16912 
      iprot.readFieldEnd()
16913 
    iprot.readStructEnd()
16914 
 
16915 
  def write(self, oprot):
16916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16918 
      return
16919 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16920 
    oprot.writeFieldStop()
16921 
    oprot.writeStructEnd()
16922 
 
16923 
  def validate(self):
16924 
    return
16925 
 
16926 
 
16927 
  def __repr__(self):
16928 
    L = ['%s=%r' % (key, value)
16929 
      for key, value in self.__dict__.iteritems()]
16930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16931 
 
16932 
  def __eq__(self, other):
16933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16934 
 
16935 
  def __ne__(self, other):
16936 
    return not (self == other)
16937 
 
16938 
class getBrandInfo_args:
16939 
 
16940 
  thrift_spec = (
16941 
  )
16942 
 
16943 
  def read(self, iprot):
16944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16946 
      return
16947 
    iprot.readStructBegin()
16948 
    while True:
16949 
      (fname, ftype, fid) = iprot.readFieldBegin()
16950 
      if ftype == TType.STOP:
16951 
        break
16952 
      else:
16953 
        iprot.skip(ftype)
16954 
      iprot.readFieldEnd()
16955 
    iprot.readStructEnd()
16956 
 
16957 
  def write(self, oprot):
16958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16960 
      return
16961 
    oprot.writeStructBegin('getBrandInfo_args')
16962 
    oprot.writeFieldStop()
16963 
    oprot.writeStructEnd()
16964 
 
16965 
  def validate(self):
16966 
    return
16967 
 
16968 
 
16969 
  def __repr__(self):
16970 
    L = ['%s=%r' % (key, value)
16971 
      for key, value in self.__dict__.iteritems()]
16972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16973 
 
16974 
  def __eq__(self, other):
16975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16976 
 
16977 
  def __ne__(self, other):
16978 
    return not (self == other)
16979 
 
16980 
class getBrandInfo_result:
16981 
  """
16982 
  Attributes:
16983 
   - success
16984 
  """
16985 
 
16986 
  thrift_spec = (
16987 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16988 
  )
16989 
 
16990 
  def __init__(self, success=None,):
16991 
    self.success = success
16992 
 
16993 
  def read(self, iprot):
16994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16996 
      return
16997 
    iprot.readStructBegin()
16998 
    while True:
16999 
      (fname, ftype, fid) = iprot.readFieldBegin()
17000 
      if ftype == TType.STOP:
17001 
        break
17002 
      if fid == 0:
17003 
        if ftype == TType.MAP:
17004 
          self.success = {}
7438 amit.gupta 17005 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
17006 
          for _i318 in xrange(_size314):
17007 
            _key319 = iprot.readString();
17008 
            _val320 = BrandInfo()
17009 
            _val320.read(iprot)
17010 
            self.success[_key319] = _val320
7272 amit.gupta 17011 
          iprot.readMapEnd()
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      else:
17015 
        iprot.skip(ftype)
17016 
      iprot.readFieldEnd()
17017 
    iprot.readStructEnd()
17018 
 
17019 
  def write(self, oprot):
17020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17022 
      return
17023 
    oprot.writeStructBegin('getBrandInfo_result')
17024 
    if self.success is not None:
17025 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17026 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 17027 
      for kiter321,viter322 in self.success.items():
17028 
        oprot.writeString(kiter321)
17029 
        viter322.write(oprot)
7272 amit.gupta 17030 
      oprot.writeMapEnd()
17031 
      oprot.writeFieldEnd()
17032 
    oprot.writeFieldStop()
17033 
    oprot.writeStructEnd()
17034 
 
17035 
  def validate(self):
17036 
    return
17037 
 
17038 
 
17039 
  def __repr__(self):
17040 
    L = ['%s=%r' % (key, value)
17041 
      for key, value in self.__dict__.iteritems()]
17042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17043 
 
17044 
  def __eq__(self, other):
17045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17046 
 
17047 
  def __ne__(self, other):
17048 
    return not (self == other)
17049 
 
7256 rajveer 17050 
class getStorePricing_args:
17051 
  """
17052 
  Attributes:
17053 
   - itemId
17054 
  """
17055 
 
17056 
  thrift_spec = (
17057 
    None, # 0
17058 
    (1, TType.I64, 'itemId', None, None, ), # 1
17059 
  )
17060 
 
17061 
  def __init__(self, itemId=None,):
17062 
    self.itemId = itemId
17063 
 
17064 
  def read(self, iprot):
17065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17067 
      return
17068 
    iprot.readStructBegin()
17069 
    while True:
17070 
      (fname, ftype, fid) = iprot.readFieldBegin()
17071 
      if ftype == TType.STOP:
17072 
        break
17073 
      if fid == 1:
17074 
        if ftype == TType.I64:
17075 
          self.itemId = iprot.readI64();
17076 
        else:
17077 
          iprot.skip(ftype)
17078 
      else:
17079 
        iprot.skip(ftype)
17080 
      iprot.readFieldEnd()
17081 
    iprot.readStructEnd()
17082 
 
17083 
  def write(self, oprot):
17084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17086 
      return
17087 
    oprot.writeStructBegin('getStorePricing_args')
17088 
    if self.itemId is not None:
17089 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17090 
      oprot.writeI64(self.itemId)
17091 
      oprot.writeFieldEnd()
17092 
    oprot.writeFieldStop()
17093 
    oprot.writeStructEnd()
17094 
 
17095 
  def validate(self):
17096 
    return
17097 
 
17098 
 
17099 
  def __repr__(self):
17100 
    L = ['%s=%r' % (key, value)
17101 
      for key, value in self.__dict__.iteritems()]
17102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17103 
 
17104 
  def __eq__(self, other):
17105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17106 
 
17107 
  def __ne__(self, other):
17108 
    return not (self == other)
17109 
 
17110 
class getStorePricing_result:
17111 
  """
17112 
  Attributes:
17113 
   - success
17114 
  """
17115 
 
17116 
  thrift_spec = (
17117 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
17118 
  )
17119 
 
17120 
  def __init__(self, success=None,):
17121 
    self.success = success
17122 
 
17123 
  def read(self, iprot):
17124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17126 
      return
17127 
    iprot.readStructBegin()
17128 
    while True:
17129 
      (fname, ftype, fid) = iprot.readFieldBegin()
17130 
      if ftype == TType.STOP:
17131 
        break
17132 
      if fid == 0:
17133 
        if ftype == TType.STRUCT:
17134 
          self.success = StorePricing()
17135 
          self.success.read(iprot)
17136 
        else:
17137 
          iprot.skip(ftype)
17138 
      else:
17139 
        iprot.skip(ftype)
17140 
      iprot.readFieldEnd()
17141 
    iprot.readStructEnd()
17142 
 
17143 
  def write(self, oprot):
17144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17146 
      return
17147 
    oprot.writeStructBegin('getStorePricing_result')
17148 
    if self.success is not None:
17149 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17150 
      self.success.write(oprot)
17151 
      oprot.writeFieldEnd()
17152 
    oprot.writeFieldStop()
17153 
    oprot.writeStructEnd()
17154 
 
17155 
  def validate(self):
17156 
    return
17157 
 
17158 
 
17159 
  def __repr__(self):
17160 
    L = ['%s=%r' % (key, value)
17161 
      for key, value in self.__dict__.iteritems()]
17162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17163 
 
17164 
  def __eq__(self, other):
17165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17166 
 
17167 
  def __ne__(self, other):
17168 
    return not (self == other)
7265 rajveer 17169 
 
7306 rajveer 17170 
class getStorePricings_args:
17171 
  """
17172 
  Attributes:
17173 
   - itemIds
17174 
  """
17175 
 
17176 
  thrift_spec = (
17177 
    None, # 0
17178 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17179 
  )
17180 
 
17181 
  def __init__(self, itemIds=None,):
17182 
    self.itemIds = itemIds
17183 
 
17184 
  def read(self, iprot):
17185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17187 
      return
17188 
    iprot.readStructBegin()
17189 
    while True:
17190 
      (fname, ftype, fid) = iprot.readFieldBegin()
17191 
      if ftype == TType.STOP:
17192 
        break
17193 
      if fid == 1:
17194 
        if ftype == TType.LIST:
17195 
          self.itemIds = []
7438 amit.gupta 17196 
          (_etype326, _size323) = iprot.readListBegin()
17197 
          for _i327 in xrange(_size323):
17198 
            _elem328 = iprot.readI64();
17199 
            self.itemIds.append(_elem328)
7306 rajveer 17200 
          iprot.readListEnd()
17201 
        else:
17202 
          iprot.skip(ftype)
17203 
      else:
17204 
        iprot.skip(ftype)
17205 
      iprot.readFieldEnd()
17206 
    iprot.readStructEnd()
17207 
 
17208 
  def write(self, oprot):
17209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17211 
      return
17212 
    oprot.writeStructBegin('getStorePricings_args')
17213 
    if self.itemIds is not None:
17214 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17215 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 17216 
      for iter329 in self.itemIds:
17217 
        oprot.writeI64(iter329)
7306 rajveer 17218 
      oprot.writeListEnd()
17219 
      oprot.writeFieldEnd()
17220 
    oprot.writeFieldStop()
17221 
    oprot.writeStructEnd()
17222 
 
17223 
  def validate(self):
17224 
    return
17225 
 
17226 
 
17227 
  def __repr__(self):
17228 
    L = ['%s=%r' % (key, value)
17229 
      for key, value in self.__dict__.iteritems()]
17230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17231 
 
17232 
  def __eq__(self, other):
17233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17234 
 
17235 
  def __ne__(self, other):
17236 
    return not (self == other)
17237 
 
17238 
class getStorePricings_result:
17239 
  """
17240 
  Attributes:
17241 
   - success
17242 
  """
17243 
 
17244 
  thrift_spec = (
17245 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
17246 
  )
17247 
 
17248 
  def __init__(self, success=None,):
17249 
    self.success = success
17250 
 
17251 
  def read(self, iprot):
17252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17254 
      return
17255 
    iprot.readStructBegin()
17256 
    while True:
17257 
      (fname, ftype, fid) = iprot.readFieldBegin()
17258 
      if ftype == TType.STOP:
17259 
        break
17260 
      if fid == 0:
17261 
        if ftype == TType.LIST:
17262 
          self.success = []
7438 amit.gupta 17263 
          (_etype333, _size330) = iprot.readListBegin()
17264 
          for _i334 in xrange(_size330):
17265 
            _elem335 = StorePricing()
17266 
            _elem335.read(iprot)
17267 
            self.success.append(_elem335)
7306 rajveer 17268 
          iprot.readListEnd()
17269 
        else:
17270 
          iprot.skip(ftype)
17271 
      else:
17272 
        iprot.skip(ftype)
17273 
      iprot.readFieldEnd()
17274 
    iprot.readStructEnd()
17275 
 
17276 
  def write(self, oprot):
17277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17279 
      return
17280 
    oprot.writeStructBegin('getStorePricings_result')
17281 
    if self.success is not None:
17282 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17283 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17284 
      for iter336 in self.success:
17285 
        iter336.write(oprot)
7306 rajveer 17286 
      oprot.writeListEnd()
17287 
      oprot.writeFieldEnd()
17288 
    oprot.writeFieldStop()
17289 
    oprot.writeStructEnd()
17290 
 
17291 
  def validate(self):
17292 
    return
17293 
 
17294 
 
17295 
  def __repr__(self):
17296 
    L = ['%s=%r' % (key, value)
17297 
      for key, value in self.__dict__.iteritems()]
17298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17299 
 
17300 
  def __eq__(self, other):
17301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17302 
 
17303 
  def __ne__(self, other):
17304 
    return not (self == other)
17305 
 
7265 rajveer 17306 
class updateStorePricing_args:
17307 
  """
17308 
  Attributes:
17309 
   - sp
7382 rajveer 17310 
   - allColors
7265 rajveer 17311 
  """
17312 
 
17313 
  thrift_spec = (
17314 
    None, # 0
17315 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 17316 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 17317 
  )
17318 
 
7382 rajveer 17319 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 17320 
    self.sp = sp
7382 rajveer 17321 
    self.allColors = allColors
7265 rajveer 17322 
 
17323 
  def read(self, iprot):
17324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17326 
      return
17327 
    iprot.readStructBegin()
17328 
    while True:
17329 
      (fname, ftype, fid) = iprot.readFieldBegin()
17330 
      if ftype == TType.STOP:
17331 
        break
17332 
      if fid == 1:
17333 
        if ftype == TType.STRUCT:
17334 
          self.sp = StorePricing()
17335 
          self.sp.read(iprot)
17336 
        else:
17337 
          iprot.skip(ftype)
7382 rajveer 17338 
      elif fid == 2:
17339 
        if ftype == TType.BOOL:
17340 
          self.allColors = iprot.readBool();
17341 
        else:
17342 
          iprot.skip(ftype)
7265 rajveer 17343 
      else:
17344 
        iprot.skip(ftype)
17345 
      iprot.readFieldEnd()
17346 
    iprot.readStructEnd()
17347 
 
17348 
  def write(self, oprot):
17349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17351 
      return
17352 
    oprot.writeStructBegin('updateStorePricing_args')
17353 
    if self.sp is not None:
17354 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
17355 
      self.sp.write(oprot)
17356 
      oprot.writeFieldEnd()
7382 rajveer 17357 
    if self.allColors is not None:
17358 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
17359 
      oprot.writeBool(self.allColors)
17360 
      oprot.writeFieldEnd()
7265 rajveer 17361 
    oprot.writeFieldStop()
17362 
    oprot.writeStructEnd()
17363 
 
17364 
  def validate(self):
17365 
    return
17366 
 
17367 
 
17368 
  def __repr__(self):
17369 
    L = ['%s=%r' % (key, value)
17370 
      for key, value in self.__dict__.iteritems()]
17371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17372 
 
17373 
  def __eq__(self, other):
17374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17375 
 
17376 
  def __ne__(self, other):
17377 
    return not (self == other)
17378 
 
17379 
class updateStorePricing_result:
17380 
 
17381 
  thrift_spec = (
17382 
  )
17383 
 
17384 
  def read(self, iprot):
17385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17387 
      return
17388 
    iprot.readStructBegin()
17389 
    while True:
17390 
      (fname, ftype, fid) = iprot.readFieldBegin()
17391 
      if ftype == TType.STOP:
17392 
        break
17393 
      else:
17394 
        iprot.skip(ftype)
17395 
      iprot.readFieldEnd()
17396 
    iprot.readStructEnd()
17397 
 
17398 
  def write(self, oprot):
17399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17401 
      return
17402 
    oprot.writeStructBegin('updateStorePricing_result')
17403 
    oprot.writeFieldStop()
17404 
    oprot.writeStructEnd()
17405 
 
17406 
  def validate(self):
17407 
    return
17408 
 
17409 
 
17410 
  def __repr__(self):
17411 
    L = ['%s=%r' % (key, value)
17412 
      for key, value in self.__dict__.iteritems()]
17413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17414 
 
17415 
  def __eq__(self, other):
17416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17417 
 
17418 
  def __ne__(self, other):
17419 
    return not (self == other)
7281 kshitij.so 17420 
 
17421 
class getAllAmazonListedItems_args:
17422 
 
17423 
  thrift_spec = (
17424 
  )
17425 
 
17426 
  def read(self, iprot):
17427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17429 
      return
17430 
    iprot.readStructBegin()
17431 
    while True:
17432 
      (fname, ftype, fid) = iprot.readFieldBegin()
17433 
      if ftype == TType.STOP:
17434 
        break
17435 
      else:
17436 
        iprot.skip(ftype)
17437 
      iprot.readFieldEnd()
17438 
    iprot.readStructEnd()
17439 
 
17440 
  def write(self, oprot):
17441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17443 
      return
17444 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17445 
    oprot.writeFieldStop()
17446 
    oprot.writeStructEnd()
17447 
 
17448 
  def validate(self):
17449 
    return
17450 
 
17451 
 
17452 
  def __repr__(self):
17453 
    L = ['%s=%r' % (key, value)
17454 
      for key, value in self.__dict__.iteritems()]
17455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17456 
 
17457 
  def __eq__(self, other):
17458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17459 
 
17460 
  def __ne__(self, other):
17461 
    return not (self == other)
17462 
 
17463 
class getAllAmazonListedItems_result:
17464 
  """
17465 
  Attributes:
17466 
   - success
17467 
  """
17468 
 
17469 
  thrift_spec = (
17470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17471 
  )
17472 
 
17473 
  def __init__(self, success=None,):
17474 
    self.success = success
17475 
 
17476 
  def read(self, iprot):
17477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17479 
      return
17480 
    iprot.readStructBegin()
17481 
    while True:
17482 
      (fname, ftype, fid) = iprot.readFieldBegin()
17483 
      if ftype == TType.STOP:
17484 
        break
17485 
      if fid == 0:
17486 
        if ftype == TType.LIST:
17487 
          self.success = []
7438 amit.gupta 17488 
          (_etype340, _size337) = iprot.readListBegin()
17489 
          for _i341 in xrange(_size337):
17490 
            _elem342 = Amazonlisted()
17491 
            _elem342.read(iprot)
17492 
            self.success.append(_elem342)
7281 kshitij.so 17493 
          iprot.readListEnd()
17494 
        else:
17495 
          iprot.skip(ftype)
17496 
      else:
17497 
        iprot.skip(ftype)
17498 
      iprot.readFieldEnd()
17499 
    iprot.readStructEnd()
17500 
 
17501 
  def write(self, oprot):
17502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17504 
      return
17505 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17506 
    if self.success is not None:
17507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17509 
      for iter343 in self.success:
17510 
        iter343.write(oprot)
7281 kshitij.so 17511 
      oprot.writeListEnd()
17512 
      oprot.writeFieldEnd()
17513 
    oprot.writeFieldStop()
17514 
    oprot.writeStructEnd()
17515 
 
17516 
  def validate(self):
17517 
    return
17518 
 
17519 
 
17520 
  def __repr__(self):
17521 
    L = ['%s=%r' % (key, value)
17522 
      for key, value in self.__dict__.iteritems()]
17523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17524 
 
17525 
  def __eq__(self, other):
17526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17527 
 
17528 
  def __ne__(self, other):
17529 
    return not (self == other)
17530 
 
17531 
class getAmazonItemDetails_args:
17532 
  """
17533 
  Attributes:
17534 
   - itemId
17535 
  """
17536 
 
17537 
  thrift_spec = (
17538 
    None, # 0
17539 
    (1, TType.I64, 'itemId', None, None, ), # 1
17540 
  )
17541 
 
17542 
  def __init__(self, itemId=None,):
17543 
    self.itemId = itemId
17544 
 
17545 
  def read(self, iprot):
17546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17548 
      return
17549 
    iprot.readStructBegin()
17550 
    while True:
17551 
      (fname, ftype, fid) = iprot.readFieldBegin()
17552 
      if ftype == TType.STOP:
17553 
        break
17554 
      if fid == 1:
17555 
        if ftype == TType.I64:
17556 
          self.itemId = iprot.readI64();
17557 
        else:
17558 
          iprot.skip(ftype)
17559 
      else:
17560 
        iprot.skip(ftype)
17561 
      iprot.readFieldEnd()
17562 
    iprot.readStructEnd()
17563 
 
17564 
  def write(self, oprot):
17565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17567 
      return
17568 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17569 
    if self.itemId is not None:
17570 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17571 
      oprot.writeI64(self.itemId)
17572 
      oprot.writeFieldEnd()
17573 
    oprot.writeFieldStop()
17574 
    oprot.writeStructEnd()
17575 
 
17576 
  def validate(self):
17577 
    return
17578 
 
17579 
 
17580 
  def __repr__(self):
17581 
    L = ['%s=%r' % (key, value)
17582 
      for key, value in self.__dict__.iteritems()]
17583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17584 
 
17585 
  def __eq__(self, other):
17586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17587 
 
17588 
  def __ne__(self, other):
17589 
    return not (self == other)
17590 
 
17591 
class getAmazonItemDetails_result:
17592 
  """
17593 
  Attributes:
17594 
   - success
17595 
  """
17596 
 
17597 
  thrift_spec = (
17598 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17599 
  )
17600 
 
17601 
  def __init__(self, success=None,):
17602 
    self.success = success
17603 
 
17604 
  def read(self, iprot):
17605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17607 
      return
17608 
    iprot.readStructBegin()
17609 
    while True:
17610 
      (fname, ftype, fid) = iprot.readFieldBegin()
17611 
      if ftype == TType.STOP:
17612 
        break
17613 
      if fid == 0:
17614 
        if ftype == TType.STRUCT:
17615 
          self.success = Amazonlisted()
17616 
          self.success.read(iprot)
17617 
        else:
17618 
          iprot.skip(ftype)
17619 
      else:
17620 
        iprot.skip(ftype)
17621 
      iprot.readFieldEnd()
17622 
    iprot.readStructEnd()
17623 
 
17624 
  def write(self, oprot):
17625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17627 
      return
17628 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17629 
    if self.success is not None:
17630 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17631 
      self.success.write(oprot)
17632 
      oprot.writeFieldEnd()
17633 
    oprot.writeFieldStop()
17634 
    oprot.writeStructEnd()
17635 
 
17636 
  def validate(self):
17637 
    return
17638 
 
17639 
 
17640 
  def __repr__(self):
17641 
    L = ['%s=%r' % (key, value)
17642 
      for key, value in self.__dict__.iteritems()]
17643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17644 
 
17645 
  def __eq__(self, other):
17646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17647 
 
17648 
  def __ne__(self, other):
17649 
    return not (self == other)
17650 
 
17651 
class updateAmazonItemDetails_args:
17652 
  """
17653 
  Attributes:
8168 kshitij.so 17654 
   - amazonlisted
7281 kshitij.so 17655 
  """
17656 
 
17657 
  thrift_spec = (
17658 
    None, # 0
8168 kshitij.so 17659 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 17660 
  )
17661 
 
8168 kshitij.so 17662 
  def __init__(self, amazonlisted=None,):
17663 
    self.amazonlisted = amazonlisted
7281 kshitij.so 17664 
 
17665 
  def read(self, iprot):
17666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17668 
      return
17669 
    iprot.readStructBegin()
17670 
    while True:
17671 
      (fname, ftype, fid) = iprot.readFieldBegin()
17672 
      if ftype == TType.STOP:
17673 
        break
17674 
      if fid == 1:
8168 kshitij.so 17675 
        if ftype == TType.STRUCT:
17676 
          self.amazonlisted = Amazonlisted()
17677 
          self.amazonlisted.read(iprot)
7281 kshitij.so 17678 
        else:
17679 
          iprot.skip(ftype)
17680 
      else:
17681 
        iprot.skip(ftype)
17682 
      iprot.readFieldEnd()
17683 
    iprot.readStructEnd()
17684 
 
17685 
  def write(self, oprot):
17686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17688 
      return
17689 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 17690 
    if self.amazonlisted is not None:
17691 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17692 
      self.amazonlisted.write(oprot)
7281 kshitij.so 17693 
      oprot.writeFieldEnd()
17694 
    oprot.writeFieldStop()
17695 
    oprot.writeStructEnd()
17696 
 
17697 
  def validate(self):
17698 
    return
17699 
 
17700 
 
17701 
  def __repr__(self):
17702 
    L = ['%s=%r' % (key, value)
17703 
      for key, value in self.__dict__.iteritems()]
17704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17705 
 
17706 
  def __eq__(self, other):
17707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17708 
 
17709 
  def __ne__(self, other):
17710 
    return not (self == other)
17711 
 
17712 
class updateAmazonItemDetails_result:
17713 
 
17714 
  thrift_spec = (
17715 
  )
17716 
 
17717 
  def read(self, iprot):
17718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17720 
      return
17721 
    iprot.readStructBegin()
17722 
    while True:
17723 
      (fname, ftype, fid) = iprot.readFieldBegin()
17724 
      if ftype == TType.STOP:
17725 
        break
17726 
      else:
17727 
        iprot.skip(ftype)
17728 
      iprot.readFieldEnd()
17729 
    iprot.readStructEnd()
17730 
 
17731 
  def write(self, oprot):
17732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17734 
      return
17735 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17736 
    oprot.writeFieldStop()
17737 
    oprot.writeStructEnd()
17738 
 
17739 
  def validate(self):
17740 
    return
17741 
 
17742 
 
17743 
  def __repr__(self):
17744 
    L = ['%s=%r' % (key, value)
17745 
      for key, value in self.__dict__.iteritems()]
17746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17747 
 
17748 
  def __eq__(self, other):
17749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17750 
 
17751 
  def __ne__(self, other):
17752 
    return not (self == other)
17753 
 
17754 
class addAmazonItem_args:
17755 
  """
17756 
  Attributes:
17757 
   - amazonlisted
17758 
  """
17759 
 
17760 
  thrift_spec = (
17761 
    None, # 0
17762 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17763 
  )
17764 
 
17765 
  def __init__(self, amazonlisted=None,):
17766 
    self.amazonlisted = amazonlisted
17767 
 
17768 
  def read(self, iprot):
17769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17771 
      return
17772 
    iprot.readStructBegin()
17773 
    while True:
17774 
      (fname, ftype, fid) = iprot.readFieldBegin()
17775 
      if ftype == TType.STOP:
17776 
        break
17777 
      if fid == 1:
17778 
        if ftype == TType.STRUCT:
17779 
          self.amazonlisted = Amazonlisted()
17780 
          self.amazonlisted.read(iprot)
17781 
        else:
17782 
          iprot.skip(ftype)
17783 
      else:
17784 
        iprot.skip(ftype)
17785 
      iprot.readFieldEnd()
17786 
    iprot.readStructEnd()
17787 
 
17788 
  def write(self, oprot):
17789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17791 
      return
17792 
    oprot.writeStructBegin('addAmazonItem_args')
17793 
    if self.amazonlisted is not None:
17794 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17795 
      self.amazonlisted.write(oprot)
17796 
      oprot.writeFieldEnd()
17797 
    oprot.writeFieldStop()
17798 
    oprot.writeStructEnd()
17799 
 
17800 
  def validate(self):
17801 
    return
17802 
 
17803 
 
17804 
  def __repr__(self):
17805 
    L = ['%s=%r' % (key, value)
17806 
      for key, value in self.__dict__.iteritems()]
17807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17808 
 
17809 
  def __eq__(self, other):
17810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17811 
 
17812 
  def __ne__(self, other):
17813 
    return not (self == other)
17814 
 
17815 
class addAmazonItem_result:
17816 
 
17817 
  thrift_spec = (
17818 
  )
17819 
 
17820 
  def read(self, iprot):
17821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17823 
      return
17824 
    iprot.readStructBegin()
17825 
    while True:
17826 
      (fname, ftype, fid) = iprot.readFieldBegin()
17827 
      if ftype == TType.STOP:
17828 
        break
17829 
      else:
17830 
        iprot.skip(ftype)
17831 
      iprot.readFieldEnd()
17832 
    iprot.readStructEnd()
17833 
 
17834 
  def write(self, oprot):
17835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17837 
      return
17838 
    oprot.writeStructBegin('addAmazonItem_result')
17839 
    oprot.writeFieldStop()
17840 
    oprot.writeStructEnd()
17841 
 
17842 
  def validate(self):
17843 
    return
17844 
 
17845 
 
17846 
  def __repr__(self):
17847 
    L = ['%s=%r' % (key, value)
17848 
      for key, value in self.__dict__.iteritems()]
17849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17850 
 
17851 
  def __eq__(self, other):
17852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17853 
 
17854 
  def __ne__(self, other):
17855 
    return not (self == other)
7291 vikram.rag 17856 
 
17857 
class getAsinItems_args:
17858 
 
17859 
  thrift_spec = (
17860 
  )
17861 
 
17862 
  def read(self, iprot):
17863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17865 
      return
17866 
    iprot.readStructBegin()
17867 
    while True:
17868 
      (fname, ftype, fid) = iprot.readFieldBegin()
17869 
      if ftype == TType.STOP:
17870 
        break
17871 
      else:
17872 
        iprot.skip(ftype)
17873 
      iprot.readFieldEnd()
17874 
    iprot.readStructEnd()
17875 
 
17876 
  def write(self, oprot):
17877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17879 
      return
17880 
    oprot.writeStructBegin('getAsinItems_args')
17881 
    oprot.writeFieldStop()
17882 
    oprot.writeStructEnd()
17883 
 
17884 
  def validate(self):
17885 
    return
17886 
 
17887 
 
17888 
  def __repr__(self):
17889 
    L = ['%s=%r' % (key, value)
17890 
      for key, value in self.__dict__.iteritems()]
17891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17892 
 
17893 
  def __eq__(self, other):
17894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17895 
 
17896 
  def __ne__(self, other):
17897 
    return not (self == other)
17898 
 
17899 
class getAsinItems_result:
17900 
  """
17901 
  Attributes:
17902 
   - success
17903 
  """
17904 
 
17905 
  thrift_spec = (
17906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17907 
  )
17908 
 
17909 
  def __init__(self, success=None,):
17910 
    self.success = success
17911 
 
17912 
  def read(self, iprot):
17913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17915 
      return
17916 
    iprot.readStructBegin()
17917 
    while True:
17918 
      (fname, ftype, fid) = iprot.readFieldBegin()
17919 
      if ftype == TType.STOP:
17920 
        break
17921 
      if fid == 0:
17922 
        if ftype == TType.LIST:
17923 
          self.success = []
7438 amit.gupta 17924 
          (_etype347, _size344) = iprot.readListBegin()
17925 
          for _i348 in xrange(_size344):
17926 
            _elem349 = Item()
17927 
            _elem349.read(iprot)
17928 
            self.success.append(_elem349)
7291 vikram.rag 17929 
          iprot.readListEnd()
17930 
        else:
17931 
          iprot.skip(ftype)
17932 
      else:
17933 
        iprot.skip(ftype)
17934 
      iprot.readFieldEnd()
17935 
    iprot.readStructEnd()
17936 
 
17937 
  def write(self, oprot):
17938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17940 
      return
17941 
    oprot.writeStructBegin('getAsinItems_result')
17942 
    if self.success is not None:
17943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17945 
      for iter350 in self.success:
17946 
        iter350.write(oprot)
7291 vikram.rag 17947 
      oprot.writeListEnd()
17948 
      oprot.writeFieldEnd()
17949 
    oprot.writeFieldStop()
17950 
    oprot.writeStructEnd()
17951 
 
17952 
  def validate(self):
17953 
    return
17954 
 
17955 
 
17956 
  def __repr__(self):
17957 
    L = ['%s=%r' % (key, value)
17958 
      for key, value in self.__dict__.iteritems()]
17959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17960 
 
17961 
  def __eq__(self, other):
17962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17963 
 
17964 
  def __ne__(self, other):
17965 
    return not (self == other)
17966 
 
17967 
class getAllFbaListedItems_args:
17968 
 
17969 
  thrift_spec = (
17970 
  )
17971 
 
17972 
  def read(self, iprot):
17973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17975 
      return
17976 
    iprot.readStructBegin()
17977 
    while True:
17978 
      (fname, ftype, fid) = iprot.readFieldBegin()
17979 
      if ftype == TType.STOP:
17980 
        break
17981 
      else:
17982 
        iprot.skip(ftype)
17983 
      iprot.readFieldEnd()
17984 
    iprot.readStructEnd()
17985 
 
17986 
  def write(self, oprot):
17987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17989 
      return
17990 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17991 
    oprot.writeFieldStop()
17992 
    oprot.writeStructEnd()
17993 
 
17994 
  def validate(self):
17995 
    return
17996 
 
17997 
 
17998 
  def __repr__(self):
17999 
    L = ['%s=%r' % (key, value)
18000 
      for key, value in self.__dict__.iteritems()]
18001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18002 
 
18003 
  def __eq__(self, other):
18004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18005 
 
18006 
  def __ne__(self, other):
18007 
    return not (self == other)
18008 
 
18009 
class getAllFbaListedItems_result:
18010 
  """
18011 
  Attributes:
18012 
   - success
18013 
  """
18014 
 
18015 
  thrift_spec = (
18016 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18017 
  )
18018 
 
18019 
  def __init__(self, success=None,):
18020 
    self.success = success
18021 
 
18022 
  def read(self, iprot):
18023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18025 
      return
18026 
    iprot.readStructBegin()
18027 
    while True:
18028 
      (fname, ftype, fid) = iprot.readFieldBegin()
18029 
      if ftype == TType.STOP:
18030 
        break
18031 
      if fid == 0:
18032 
        if ftype == TType.LIST:
18033 
          self.success = []
7438 amit.gupta 18034 
          (_etype354, _size351) = iprot.readListBegin()
18035 
          for _i355 in xrange(_size351):
18036 
            _elem356 = Amazonlisted()
18037 
            _elem356.read(iprot)
18038 
            self.success.append(_elem356)
7291 vikram.rag 18039 
          iprot.readListEnd()
18040 
        else:
18041 
          iprot.skip(ftype)
18042 
      else:
18043 
        iprot.skip(ftype)
18044 
      iprot.readFieldEnd()
18045 
    iprot.readStructEnd()
18046 
 
18047 
  def write(self, oprot):
18048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18050 
      return
18051 
    oprot.writeStructBegin('getAllFbaListedItems_result')
18052 
    if self.success is not None:
18053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18055 
      for iter357 in self.success:
18056 
        iter357.write(oprot)
7291 vikram.rag 18057 
      oprot.writeListEnd()
18058 
      oprot.writeFieldEnd()
18059 
    oprot.writeFieldStop()
18060 
    oprot.writeStructEnd()
18061 
 
18062 
  def validate(self):
18063 
    return
18064 
 
18065 
 
18066 
  def __repr__(self):
18067 
    L = ['%s=%r' % (key, value)
18068 
      for key, value in self.__dict__.iteritems()]
18069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18070 
 
18071 
  def __eq__(self, other):
18072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18073 
 
18074 
  def __ne__(self, other):
18075 
    return not (self == other)
18076 
 
18077 
class getAllNonFbaListedItems_args:
18078 
 
18079 
  thrift_spec = (
18080 
  )
18081 
 
18082 
  def read(self, iprot):
18083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18085 
      return
18086 
    iprot.readStructBegin()
18087 
    while True:
18088 
      (fname, ftype, fid) = iprot.readFieldBegin()
18089 
      if ftype == TType.STOP:
18090 
        break
18091 
      else:
18092 
        iprot.skip(ftype)
18093 
      iprot.readFieldEnd()
18094 
    iprot.readStructEnd()
18095 
 
18096 
  def write(self, oprot):
18097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18099 
      return
18100 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
18101 
    oprot.writeFieldStop()
18102 
    oprot.writeStructEnd()
18103 
 
18104 
  def validate(self):
18105 
    return
18106 
 
18107 
 
18108 
  def __repr__(self):
18109 
    L = ['%s=%r' % (key, value)
18110 
      for key, value in self.__dict__.iteritems()]
18111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18112 
 
18113 
  def __eq__(self, other):
18114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18115 
 
18116 
  def __ne__(self, other):
18117 
    return not (self == other)
18118 
 
18119 
class getAllNonFbaListedItems_result:
18120 
  """
18121 
  Attributes:
18122 
   - success
18123 
  """
18124 
 
18125 
  thrift_spec = (
18126 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18127 
  )
18128 
 
18129 
  def __init__(self, success=None,):
18130 
    self.success = success
18131 
 
18132 
  def read(self, iprot):
18133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18135 
      return
18136 
    iprot.readStructBegin()
18137 
    while True:
18138 
      (fname, ftype, fid) = iprot.readFieldBegin()
18139 
      if ftype == TType.STOP:
18140 
        break
18141 
      if fid == 0:
18142 
        if ftype == TType.LIST:
18143 
          self.success = []
7438 amit.gupta 18144 
          (_etype361, _size358) = iprot.readListBegin()
18145 
          for _i362 in xrange(_size358):
18146 
            _elem363 = Amazonlisted()
18147 
            _elem363.read(iprot)
18148 
            self.success.append(_elem363)
7291 vikram.rag 18149 
          iprot.readListEnd()
18150 
        else:
18151 
          iprot.skip(ftype)
18152 
      else:
18153 
        iprot.skip(ftype)
18154 
      iprot.readFieldEnd()
18155 
    iprot.readStructEnd()
18156 
 
18157 
  def write(self, oprot):
18158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18160 
      return
18161 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
18162 
    if self.success is not None:
18163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18165 
      for iter364 in self.success:
18166 
        iter364.write(oprot)
7291 vikram.rag 18167 
      oprot.writeListEnd()
18168 
      oprot.writeFieldEnd()
18169 
    oprot.writeFieldStop()
18170 
    oprot.writeStructEnd()
18171 
 
18172 
  def validate(self):
18173 
    return
18174 
 
18175 
 
18176 
  def __repr__(self):
18177 
    L = ['%s=%r' % (key, value)
18178 
      for key, value in self.__dict__.iteritems()]
18179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18180 
 
18181 
  def __eq__(self, other):
18182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18183 
 
18184 
  def __ne__(self, other):
18185 
    return not (self == other)
7460 kshitij.so 18186 
 
18187 
class updateItemInventory_args:
18188 
  """
18189 
  Attributes:
18190 
   - itemId
18191 
   - holdInventory
18192 
   - defaultInventory
18193 
  """
18194 
 
18195 
  thrift_spec = (
18196 
    None, # 0
18197 
    (1, TType.I64, 'itemId', None, None, ), # 1
18198 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
18199 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
18200 
  )
18201 
 
18202 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
18203 
    self.itemId = itemId
18204 
    self.holdInventory = holdInventory
18205 
    self.defaultInventory = defaultInventory
18206 
 
18207 
  def read(self, iprot):
18208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18210 
      return
18211 
    iprot.readStructBegin()
18212 
    while True:
18213 
      (fname, ftype, fid) = iprot.readFieldBegin()
18214 
      if ftype == TType.STOP:
18215 
        break
18216 
      if fid == 1:
18217 
        if ftype == TType.I64:
18218 
          self.itemId = iprot.readI64();
18219 
        else:
18220 
          iprot.skip(ftype)
18221 
      elif fid == 2:
18222 
        if ftype == TType.I64:
18223 
          self.holdInventory = iprot.readI64();
18224 
        else:
18225 
          iprot.skip(ftype)
18226 
      elif fid == 3:
18227 
        if ftype == TType.I64:
18228 
          self.defaultInventory = iprot.readI64();
18229 
        else:
18230 
          iprot.skip(ftype)
18231 
      else:
18232 
        iprot.skip(ftype)
18233 
      iprot.readFieldEnd()
18234 
    iprot.readStructEnd()
18235 
 
18236 
  def write(self, oprot):
18237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18239 
      return
18240 
    oprot.writeStructBegin('updateItemInventory_args')
18241 
    if self.itemId is not None:
18242 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18243 
      oprot.writeI64(self.itemId)
18244 
      oprot.writeFieldEnd()
18245 
    if self.holdInventory is not None:
18246 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
18247 
      oprot.writeI64(self.holdInventory)
18248 
      oprot.writeFieldEnd()
18249 
    if self.defaultInventory is not None:
18250 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
18251 
      oprot.writeI64(self.defaultInventory)
18252 
      oprot.writeFieldEnd()
18253 
    oprot.writeFieldStop()
18254 
    oprot.writeStructEnd()
18255 
 
18256 
  def validate(self):
18257 
    return
18258 
 
18259 
 
18260 
  def __repr__(self):
18261 
    L = ['%s=%r' % (key, value)
18262 
      for key, value in self.__dict__.iteritems()]
18263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18264 
 
18265 
  def __eq__(self, other):
18266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18267 
 
18268 
  def __ne__(self, other):
18269 
    return not (self == other)
18270 
 
18271 
class updateItemInventory_result:
18272 
  """
18273 
  Attributes:
18274 
   - success
18275 
  """
18276 
 
18277 
  thrift_spec = (
18278 
    (0, TType.BOOL, 'success', None, None, ), # 0
18279 
  )
18280 
 
18281 
  def __init__(self, success=None,):
18282 
    self.success = success
18283 
 
18284 
  def read(self, iprot):
18285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18287 
      return
18288 
    iprot.readStructBegin()
18289 
    while True:
18290 
      (fname, ftype, fid) = iprot.readFieldBegin()
18291 
      if ftype == TType.STOP:
18292 
        break
18293 
      if fid == 0:
18294 
        if ftype == TType.BOOL:
18295 
          self.success = iprot.readBool();
18296 
        else:
18297 
          iprot.skip(ftype)
18298 
      else:
18299 
        iprot.skip(ftype)
18300 
      iprot.readFieldEnd()
18301 
    iprot.readStructEnd()
18302 
 
18303 
  def write(self, oprot):
18304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18306 
      return
18307 
    oprot.writeStructBegin('updateItemInventory_result')
18308 
    if self.success is not None:
18309 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18310 
      oprot.writeBool(self.success)
18311 
      oprot.writeFieldEnd()
18312 
    oprot.writeFieldStop()
18313 
    oprot.writeStructEnd()
18314 
 
18315 
  def validate(self):
18316 
    return
18317 
 
18318 
 
18319 
  def __repr__(self):
18320 
    L = ['%s=%r' % (key, value)
18321 
      for key, value in self.__dict__.iteritems()]
18322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18323 
 
18324 
  def __eq__(self, other):
18325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18326 
 
18327 
  def __ne__(self, other):
18328 
    return not (self == other)
7770 kshitij.so 18329 
 
18330 
class updateTimestampForAmazonFeeds_args:
18331 
  """
18332 
  Attributes:
18333 
   - type
18334 
   - sku
18335 
   - timestamp
18336 
  """
18337 
 
18338 
  thrift_spec = (
18339 
    None, # 0
18340 
    (1, TType.STRING, 'type', None, None, ), # 1
18341 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18342 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18343 
  )
18344 
 
18345 
  def __init__(self, type=None, sku=None, timestamp=None,):
18346 
    self.type = type
18347 
    self.sku = sku
18348 
    self.timestamp = timestamp
18349 
 
18350 
  def read(self, iprot):
18351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18353 
      return
18354 
    iprot.readStructBegin()
18355 
    while True:
18356 
      (fname, ftype, fid) = iprot.readFieldBegin()
18357 
      if ftype == TType.STOP:
18358 
        break
18359 
      if fid == 1:
18360 
        if ftype == TType.STRING:
18361 
          self.type = iprot.readString();
18362 
        else:
18363 
          iprot.skip(ftype)
18364 
      elif fid == 2:
18365 
        if ftype == TType.LIST:
18366 
          self.sku = []
18367 
          (_etype368, _size365) = iprot.readListBegin()
18368 
          for _i369 in xrange(_size365):
18369 
            _elem370 = iprot.readI64();
18370 
            self.sku.append(_elem370)
18371 
          iprot.readListEnd()
18372 
        else:
18373 
          iprot.skip(ftype)
18374 
      elif fid == 3:
18375 
        if ftype == TType.I64:
18376 
          self.timestamp = iprot.readI64();
18377 
        else:
18378 
          iprot.skip(ftype)
18379 
      else:
18380 
        iprot.skip(ftype)
18381 
      iprot.readFieldEnd()
18382 
    iprot.readStructEnd()
18383 
 
18384 
  def write(self, oprot):
18385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18387 
      return
18388 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18389 
    if self.type is not None:
18390 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18391 
      oprot.writeString(self.type)
18392 
      oprot.writeFieldEnd()
18393 
    if self.sku is not None:
18394 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18395 
      oprot.writeListBegin(TType.I64, len(self.sku))
18396 
      for iter371 in self.sku:
18397 
        oprot.writeI64(iter371)
18398 
      oprot.writeListEnd()
18399 
      oprot.writeFieldEnd()
18400 
    if self.timestamp is not None:
18401 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18402 
      oprot.writeI64(self.timestamp)
18403 
      oprot.writeFieldEnd()
18404 
    oprot.writeFieldStop()
18405 
    oprot.writeStructEnd()
18406 
 
18407 
  def validate(self):
18408 
    return
18409 
 
18410 
 
18411 
  def __repr__(self):
18412 
    L = ['%s=%r' % (key, value)
18413 
      for key, value in self.__dict__.iteritems()]
18414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18415 
 
18416 
  def __eq__(self, other):
18417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18418 
 
18419 
  def __ne__(self, other):
18420 
    return not (self == other)
18421 
 
18422 
class updateTimestampForAmazonFeeds_result:
18423 
  """
18424 
  Attributes:
18425 
   - success
18426 
  """
18427 
 
18428 
  thrift_spec = (
18429 
    (0, TType.BOOL, 'success', None, None, ), # 0
18430 
  )
18431 
 
18432 
  def __init__(self, success=None,):
18433 
    self.success = success
18434 
 
18435 
  def read(self, iprot):
18436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18438 
      return
18439 
    iprot.readStructBegin()
18440 
    while True:
18441 
      (fname, ftype, fid) = iprot.readFieldBegin()
18442 
      if ftype == TType.STOP:
18443 
        break
18444 
      if fid == 0:
18445 
        if ftype == TType.BOOL:
18446 
          self.success = iprot.readBool();
18447 
        else:
18448 
          iprot.skip(ftype)
18449 
      else:
18450 
        iprot.skip(ftype)
18451 
      iprot.readFieldEnd()
18452 
    iprot.readStructEnd()
18453 
 
18454 
  def write(self, oprot):
18455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18457 
      return
18458 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18459 
    if self.success is not None:
18460 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18461 
      oprot.writeBool(self.success)
18462 
      oprot.writeFieldEnd()
18463 
    oprot.writeFieldStop()
18464 
    oprot.writeStructEnd()
18465 
 
18466 
  def validate(self):
18467 
    return
18468 
 
18469 
 
18470 
  def __repr__(self):
18471 
    L = ['%s=%r' % (key, value)
18472 
      for key, value in self.__dict__.iteritems()]
18473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18474 
 
18475 
  def __eq__(self, other):
18476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18477 
 
18478 
  def __ne__(self, other):
18479 
    return not (self == other)
7897 amar.kumar 18480 
 
18481 
class getAllParentCategories_args:
18482 
 
18483 
  thrift_spec = (
18484 
  )
18485 
 
18486 
  def read(self, iprot):
18487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18489 
      return
18490 
    iprot.readStructBegin()
18491 
    while True:
18492 
      (fname, ftype, fid) = iprot.readFieldBegin()
18493 
      if ftype == TType.STOP:
18494 
        break
18495 
      else:
18496 
        iprot.skip(ftype)
18497 
      iprot.readFieldEnd()
18498 
    iprot.readStructEnd()
18499 
 
18500 
  def write(self, oprot):
18501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18503 
      return
18504 
    oprot.writeStructBegin('getAllParentCategories_args')
18505 
    oprot.writeFieldStop()
18506 
    oprot.writeStructEnd()
18507 
 
18508 
  def validate(self):
18509 
    return
18510 
 
18511 
 
18512 
  def __repr__(self):
18513 
    L = ['%s=%r' % (key, value)
18514 
      for key, value in self.__dict__.iteritems()]
18515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18516 
 
18517 
  def __eq__(self, other):
18518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18519 
 
18520 
  def __ne__(self, other):
18521 
    return not (self == other)
18522 
 
18523 
class getAllParentCategories_result:
18524 
  """
18525 
  Attributes:
18526 
   - success
18527 
  """
18528 
 
18529 
  thrift_spec = (
18530 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
18531 
  )
18532 
 
18533 
  def __init__(self, success=None,):
18534 
    self.success = success
18535 
 
18536 
  def read(self, iprot):
18537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18539 
      return
18540 
    iprot.readStructBegin()
18541 
    while True:
18542 
      (fname, ftype, fid) = iprot.readFieldBegin()
18543 
      if ftype == TType.STOP:
18544 
        break
18545 
      if fid == 0:
18546 
        if ftype == TType.LIST:
18547 
          self.success = []
18548 
          (_etype375, _size372) = iprot.readListBegin()
18549 
          for _i376 in xrange(_size372):
18550 
            _elem377 = Category()
18551 
            _elem377.read(iprot)
18552 
            self.success.append(_elem377)
18553 
          iprot.readListEnd()
18554 
        else:
18555 
          iprot.skip(ftype)
18556 
      else:
18557 
        iprot.skip(ftype)
18558 
      iprot.readFieldEnd()
18559 
    iprot.readStructEnd()
18560 
 
18561 
  def write(self, oprot):
18562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18564 
      return
18565 
    oprot.writeStructBegin('getAllParentCategories_result')
18566 
    if self.success is not None:
18567 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18568 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18569 
      for iter378 in self.success:
18570 
        iter378.write(oprot)
18571 
      oprot.writeListEnd()
18572 
      oprot.writeFieldEnd()
18573 
    oprot.writeFieldStop()
18574 
    oprot.writeStructEnd()
18575 
 
18576 
  def validate(self):
18577 
    return
18578 
 
18579 
 
18580 
  def __repr__(self):
18581 
    L = ['%s=%r' % (key, value)
18582 
      for key, value in self.__dict__.iteritems()]
18583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18584 
 
18585 
  def __eq__(self, other):
18586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18587 
 
18588 
  def __ne__(self, other):
18589 
    return not (self == other)
7977 kshitij.so 18590 
 
18591 
class addPageViewEvent_args:
18592 
  """
18593 
  Attributes:
18594 
   - pageViewEvents
18595 
  """
18596 
 
18597 
  thrift_spec = (
18598 
    None, # 0
18599 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
18600 
  )
18601 
 
18602 
  def __init__(self, pageViewEvents=None,):
18603 
    self.pageViewEvents = pageViewEvents
18604 
 
18605 
  def read(self, iprot):
18606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18608 
      return
18609 
    iprot.readStructBegin()
18610 
    while True:
18611 
      (fname, ftype, fid) = iprot.readFieldBegin()
18612 
      if ftype == TType.STOP:
18613 
        break
18614 
      if fid == 1:
18615 
        if ftype == TType.STRUCT:
18616 
          self.pageViewEvents = PageViewEvents()
18617 
          self.pageViewEvents.read(iprot)
18618 
        else:
18619 
          iprot.skip(ftype)
18620 
      else:
18621 
        iprot.skip(ftype)
18622 
      iprot.readFieldEnd()
18623 
    iprot.readStructEnd()
18624 
 
18625 
  def write(self, oprot):
18626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18628 
      return
18629 
    oprot.writeStructBegin('addPageViewEvent_args')
18630 
    if self.pageViewEvents is not None:
18631 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
18632 
      self.pageViewEvents.write(oprot)
18633 
      oprot.writeFieldEnd()
18634 
    oprot.writeFieldStop()
18635 
    oprot.writeStructEnd()
18636 
 
18637 
  def validate(self):
18638 
    return
18639 
 
18640 
 
18641 
  def __repr__(self):
18642 
    L = ['%s=%r' % (key, value)
18643 
      for key, value in self.__dict__.iteritems()]
18644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18645 
 
18646 
  def __eq__(self, other):
18647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18648 
 
18649 
  def __ne__(self, other):
18650 
    return not (self == other)
18651 
 
18652 
class addPageViewEvent_result:
18653 
 
18654 
  thrift_spec = (
18655 
  )
18656 
 
18657 
  def read(self, iprot):
18658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18660 
      return
18661 
    iprot.readStructBegin()
18662 
    while True:
18663 
      (fname, ftype, fid) = iprot.readFieldBegin()
18664 
      if ftype == TType.STOP:
18665 
        break
18666 
      else:
18667 
        iprot.skip(ftype)
18668 
      iprot.readFieldEnd()
18669 
    iprot.readStructEnd()
18670 
 
18671 
  def write(self, oprot):
18672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18674 
      return
18675 
    oprot.writeStructBegin('addPageViewEvent_result')
18676 
    oprot.writeFieldStop()
18677 
    oprot.writeStructEnd()
18678 
 
18679 
  def validate(self):
18680 
    return
18681 
 
18682 
 
18683 
  def __repr__(self):
18684 
    L = ['%s=%r' % (key, value)
18685 
      for key, value in self.__dict__.iteritems()]
18686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18687 
 
18688 
  def __eq__(self, other):
18689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18690 
 
18691 
  def __ne__(self, other):
18692 
    return not (self == other)
18693 
 
18694 
class addCartEvent_args:
18695 
  """
18696 
  Attributes:
18697 
   - cartEvents
18698 
  """
18699 
 
18700 
  thrift_spec = (
18701 
    None, # 0
18702 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
18703 
  )
18704 
 
18705 
  def __init__(self, cartEvents=None,):
18706 
    self.cartEvents = cartEvents
18707 
 
18708 
  def read(self, iprot):
18709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18711 
      return
18712 
    iprot.readStructBegin()
18713 
    while True:
18714 
      (fname, ftype, fid) = iprot.readFieldBegin()
18715 
      if ftype == TType.STOP:
18716 
        break
18717 
      if fid == 1:
18718 
        if ftype == TType.STRUCT:
18719 
          self.cartEvents = CartEvents()
18720 
          self.cartEvents.read(iprot)
18721 
        else:
18722 
          iprot.skip(ftype)
18723 
      else:
18724 
        iprot.skip(ftype)
18725 
      iprot.readFieldEnd()
18726 
    iprot.readStructEnd()
18727 
 
18728 
  def write(self, oprot):
18729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18731 
      return
18732 
    oprot.writeStructBegin('addCartEvent_args')
18733 
    if self.cartEvents is not None:
18734 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
18735 
      self.cartEvents.write(oprot)
18736 
      oprot.writeFieldEnd()
18737 
    oprot.writeFieldStop()
18738 
    oprot.writeStructEnd()
18739 
 
18740 
  def validate(self):
18741 
    return
18742 
 
18743 
 
18744 
  def __repr__(self):
18745 
    L = ['%s=%r' % (key, value)
18746 
      for key, value in self.__dict__.iteritems()]
18747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18748 
 
18749 
  def __eq__(self, other):
18750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18751 
 
18752 
  def __ne__(self, other):
18753 
    return not (self == other)
18754 
 
18755 
class addCartEvent_result:
18756 
 
18757 
  thrift_spec = (
18758 
  )
18759 
 
18760 
  def read(self, iprot):
18761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18763 
      return
18764 
    iprot.readStructBegin()
18765 
    while True:
18766 
      (fname, ftype, fid) = iprot.readFieldBegin()
18767 
      if ftype == TType.STOP:
18768 
        break
18769 
      else:
18770 
        iprot.skip(ftype)
18771 
      iprot.readFieldEnd()
18772 
    iprot.readStructEnd()
18773 
 
18774 
  def write(self, oprot):
18775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18777 
      return
18778 
    oprot.writeStructBegin('addCartEvent_result')
18779 
    oprot.writeFieldStop()
18780 
    oprot.writeStructEnd()
18781 
 
18782 
  def validate(self):
18783 
    return
18784 
 
18785 
 
18786 
  def __repr__(self):
18787 
    L = ['%s=%r' % (key, value)
18788 
      for key, value in self.__dict__.iteritems()]
18789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18790 
 
18791 
  def __eq__(self, other):
18792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18793 
 
18794 
  def __ne__(self, other):
18795 
    return not (self == other)
8139 kshitij.so 18796 
 
8182 amar.kumar 18797 
class addEbayItem_args:
18798 
  """
18799 
  Attributes:
18800 
   - ebayItem
18801 
  """
18802 
 
18803 
  thrift_spec = (
18804 
    None, # 0
18805 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
18806 
  )
18807 
 
18808 
  def __init__(self, ebayItem=None,):
18809 
    self.ebayItem = ebayItem
18810 
 
18811 
  def read(self, iprot):
18812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18814 
      return
18815 
    iprot.readStructBegin()
18816 
    while True:
18817 
      (fname, ftype, fid) = iprot.readFieldBegin()
18818 
      if ftype == TType.STOP:
18819 
        break
18820 
      if fid == 1:
18821 
        if ftype == TType.STRUCT:
18822 
          self.ebayItem = EbayItem()
18823 
          self.ebayItem.read(iprot)
18824 
        else:
18825 
          iprot.skip(ftype)
18826 
      else:
18827 
        iprot.skip(ftype)
18828 
      iprot.readFieldEnd()
18829 
    iprot.readStructEnd()
18830 
 
18831 
  def write(self, oprot):
18832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18834 
      return
18835 
    oprot.writeStructBegin('addEbayItem_args')
18836 
    if self.ebayItem is not None:
18837 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
18838 
      self.ebayItem.write(oprot)
18839 
      oprot.writeFieldEnd()
18840 
    oprot.writeFieldStop()
18841 
    oprot.writeStructEnd()
18842 
 
18843 
  def validate(self):
18844 
    return
18845 
 
18846 
 
18847 
  def __repr__(self):
18848 
    L = ['%s=%r' % (key, value)
18849 
      for key, value in self.__dict__.iteritems()]
18850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18851 
 
18852 
  def __eq__(self, other):
18853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18854 
 
18855 
  def __ne__(self, other):
18856 
    return not (self == other)
18857 
 
18858 
class addEbayItem_result:
18859 
 
18860 
  thrift_spec = (
18861 
  )
18862 
 
18863 
  def read(self, iprot):
18864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18866 
      return
18867 
    iprot.readStructBegin()
18868 
    while True:
18869 
      (fname, ftype, fid) = iprot.readFieldBegin()
18870 
      if ftype == TType.STOP:
18871 
        break
18872 
      else:
18873 
        iprot.skip(ftype)
18874 
      iprot.readFieldEnd()
18875 
    iprot.readStructEnd()
18876 
 
18877 
  def write(self, oprot):
18878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18880 
      return
18881 
    oprot.writeStructBegin('addEbayItem_result')
18882 
    oprot.writeFieldStop()
18883 
    oprot.writeStructEnd()
18884 
 
18885 
  def validate(self):
18886 
    return
18887 
 
18888 
 
18889 
  def __repr__(self):
18890 
    L = ['%s=%r' % (key, value)
18891 
      for key, value in self.__dict__.iteritems()]
18892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18893 
 
18894 
  def __eq__(self, other):
18895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18896 
 
18897 
  def __ne__(self, other):
18898 
    return not (self == other)
18899 
 
18900 
class getEbayItem_args:
18901 
  """
18902 
  Attributes:
18903 
   - listingId
18904 
  """
18905 
 
18906 
  thrift_spec = (
18907 
    None, # 0
18908 
    (1, TType.STRING, 'listingId', None, None, ), # 1
18909 
  )
18910 
 
18911 
  def __init__(self, listingId=None,):
18912 
    self.listingId = listingId
18913 
 
18914 
  def read(self, iprot):
18915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18917 
      return
18918 
    iprot.readStructBegin()
18919 
    while True:
18920 
      (fname, ftype, fid) = iprot.readFieldBegin()
18921 
      if ftype == TType.STOP:
18922 
        break
18923 
      if fid == 1:
18924 
        if ftype == TType.STRING:
18925 
          self.listingId = iprot.readString();
18926 
        else:
18927 
          iprot.skip(ftype)
18928 
      else:
18929 
        iprot.skip(ftype)
18930 
      iprot.readFieldEnd()
18931 
    iprot.readStructEnd()
18932 
 
18933 
  def write(self, oprot):
18934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18936 
      return
18937 
    oprot.writeStructBegin('getEbayItem_args')
18938 
    if self.listingId is not None:
18939 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
18940 
      oprot.writeString(self.listingId)
18941 
      oprot.writeFieldEnd()
18942 
    oprot.writeFieldStop()
18943 
    oprot.writeStructEnd()
18944 
 
18945 
  def validate(self):
18946 
    return
18947 
 
18948 
 
18949 
  def __repr__(self):
18950 
    L = ['%s=%r' % (key, value)
18951 
      for key, value in self.__dict__.iteritems()]
18952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18953 
 
18954 
  def __eq__(self, other):
18955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18956 
 
18957 
  def __ne__(self, other):
18958 
    return not (self == other)
18959 
 
18960 
class getEbayItem_result:
18961 
  """
18962 
  Attributes:
18963 
   - success
18964 
  """
18965 
 
18966 
  thrift_spec = (
18967 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
18968 
  )
18969 
 
18970 
  def __init__(self, success=None,):
18971 
    self.success = success
18972 
 
18973 
  def read(self, iprot):
18974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18976 
      return
18977 
    iprot.readStructBegin()
18978 
    while True:
18979 
      (fname, ftype, fid) = iprot.readFieldBegin()
18980 
      if ftype == TType.STOP:
18981 
        break
18982 
      if fid == 0:
18983 
        if ftype == TType.STRUCT:
18984 
          self.success = EbayItem()
18985 
          self.success.read(iprot)
18986 
        else:
18987 
          iprot.skip(ftype)
18988 
      else:
18989 
        iprot.skip(ftype)
18990 
      iprot.readFieldEnd()
18991 
    iprot.readStructEnd()
18992 
 
18993 
  def write(self, oprot):
18994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18996 
      return
18997 
    oprot.writeStructBegin('getEbayItem_result')
18998 
    if self.success is not None:
18999 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19000 
      self.success.write(oprot)
19001 
      oprot.writeFieldEnd()
19002 
    oprot.writeFieldStop()
19003 
    oprot.writeStructEnd()
19004 
 
19005 
  def validate(self):
19006 
    return
19007 
 
19008 
 
19009 
  def __repr__(self):
19010 
    L = ['%s=%r' % (key, value)
19011 
      for key, value in self.__dict__.iteritems()]
19012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19013 
 
19014 
  def __eq__(self, other):
19015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19016 
 
19017 
  def __ne__(self, other):
19018 
    return not (self == other)
19019 
 
19020 
class updateEbayItem_args:
19021 
  """
19022 
  Attributes:
19023 
   - ebayItem
19024 
  """
19025 
 
19026 
  thrift_spec = (
19027 
    None, # 0
19028 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
19029 
  )
19030 
 
19031 
  def __init__(self, ebayItem=None,):
19032 
    self.ebayItem = ebayItem
19033 
 
19034 
  def read(self, iprot):
19035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19037 
      return
19038 
    iprot.readStructBegin()
19039 
    while True:
19040 
      (fname, ftype, fid) = iprot.readFieldBegin()
19041 
      if ftype == TType.STOP:
19042 
        break
19043 
      if fid == 1:
19044 
        if ftype == TType.STRUCT:
19045 
          self.ebayItem = EbayItem()
19046 
          self.ebayItem.read(iprot)
19047 
        else:
19048 
          iprot.skip(ftype)
19049 
      else:
19050 
        iprot.skip(ftype)
19051 
      iprot.readFieldEnd()
19052 
    iprot.readStructEnd()
19053 
 
19054 
  def write(self, oprot):
19055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19057 
      return
19058 
    oprot.writeStructBegin('updateEbayItem_args')
19059 
    if self.ebayItem is not None:
19060 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
19061 
      self.ebayItem.write(oprot)
19062 
      oprot.writeFieldEnd()
19063 
    oprot.writeFieldStop()
19064 
    oprot.writeStructEnd()
19065 
 
19066 
  def validate(self):
19067 
    return
19068 
 
19069 
 
19070 
  def __repr__(self):
19071 
    L = ['%s=%r' % (key, value)
19072 
      for key, value in self.__dict__.iteritems()]
19073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19074 
 
19075 
  def __eq__(self, other):
19076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19077 
 
19078 
  def __ne__(self, other):
19079 
    return not (self == other)
19080 
 
19081 
class updateEbayItem_result:
19082 
 
19083 
  thrift_spec = (
19084 
  )
19085 
 
19086 
  def read(self, iprot):
19087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19089 
      return
19090 
    iprot.readStructBegin()
19091 
    while True:
19092 
      (fname, ftype, fid) = iprot.readFieldBegin()
19093 
      if ftype == TType.STOP:
19094 
        break
19095 
      else:
19096 
        iprot.skip(ftype)
19097 
      iprot.readFieldEnd()
19098 
    iprot.readStructEnd()
19099 
 
19100 
  def write(self, oprot):
19101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19103 
      return
19104 
    oprot.writeStructBegin('updateEbayItem_result')
19105 
    oprot.writeFieldStop()
19106 
    oprot.writeStructEnd()
19107 
 
19108 
  def validate(self):
19109 
    return
19110 
 
19111 
 
19112 
  def __repr__(self):
19113 
    L = ['%s=%r' % (key, value)
19114 
      for key, value in self.__dict__.iteritems()]
19115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19116 
 
19117 
  def __eq__(self, other):
19118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19119 
 
19120 
  def __ne__(self, other):
19121 
    return not (self == other)
19122 
 
8139 kshitij.so 19123 
class getAmazonListedItems_args:
19124 
  """
19125 
  Attributes:
19126 
   - offset
19127 
   - limit
19128 
  """
19129 
 
19130 
  thrift_spec = (
19131 
    None, # 0
19132 
    (1, TType.I64, 'offset', None, None, ), # 1
19133 
    (2, TType.I64, 'limit', None, None, ), # 2
19134 
  )
19135 
 
19136 
  def __init__(self, offset=None, limit=None,):
19137 
    self.offset = offset
19138 
    self.limit = limit
19139 
 
19140 
  def read(self, iprot):
19141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19143 
      return
19144 
    iprot.readStructBegin()
19145 
    while True:
19146 
      (fname, ftype, fid) = iprot.readFieldBegin()
19147 
      if ftype == TType.STOP:
19148 
        break
19149 
      if fid == 1:
19150 
        if ftype == TType.I64:
19151 
          self.offset = iprot.readI64();
19152 
        else:
19153 
          iprot.skip(ftype)
19154 
      elif fid == 2:
19155 
        if ftype == TType.I64:
19156 
          self.limit = iprot.readI64();
19157 
        else:
19158 
          iprot.skip(ftype)
19159 
      else:
19160 
        iprot.skip(ftype)
19161 
      iprot.readFieldEnd()
19162 
    iprot.readStructEnd()
19163 
 
19164 
  def write(self, oprot):
19165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19167 
      return
19168 
    oprot.writeStructBegin('getAmazonListedItems_args')
19169 
    if self.offset is not None:
19170 
      oprot.writeFieldBegin('offset', TType.I64, 1)
19171 
      oprot.writeI64(self.offset)
19172 
      oprot.writeFieldEnd()
19173 
    if self.limit is not None:
19174 
      oprot.writeFieldBegin('limit', TType.I64, 2)
19175 
      oprot.writeI64(self.limit)
19176 
      oprot.writeFieldEnd()
19177 
    oprot.writeFieldStop()
19178 
    oprot.writeStructEnd()
19179 
 
19180 
  def validate(self):
19181 
    return
19182 
 
19183 
 
19184 
  def __repr__(self):
19185 
    L = ['%s=%r' % (key, value)
19186 
      for key, value in self.__dict__.iteritems()]
19187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19188 
 
19189 
  def __eq__(self, other):
19190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19191 
 
19192 
  def __ne__(self, other):
19193 
    return not (self == other)
19194 
 
19195 
class getAmazonListedItems_result:
19196 
  """
19197 
  Attributes:
19198 
   - success
19199 
  """
19200 
 
19201 
  thrift_spec = (
19202 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19203 
  )
19204 
 
19205 
  def __init__(self, success=None,):
19206 
    self.success = success
19207 
 
19208 
  def read(self, iprot):
19209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19211 
      return
19212 
    iprot.readStructBegin()
19213 
    while True:
19214 
      (fname, ftype, fid) = iprot.readFieldBegin()
19215 
      if ftype == TType.STOP:
19216 
        break
19217 
      if fid == 0:
19218 
        if ftype == TType.LIST:
19219 
          self.success = []
19220 
          (_etype382, _size379) = iprot.readListBegin()
19221 
          for _i383 in xrange(_size379):
19222 
            _elem384 = Amazonlisted()
19223 
            _elem384.read(iprot)
19224 
            self.success.append(_elem384)
19225 
          iprot.readListEnd()
19226 
        else:
19227 
          iprot.skip(ftype)
19228 
      else:
19229 
        iprot.skip(ftype)
19230 
      iprot.readFieldEnd()
19231 
    iprot.readStructEnd()
19232 
 
19233 
  def write(self, oprot):
19234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19236 
      return
19237 
    oprot.writeStructBegin('getAmazonListedItems_result')
19238 
    if self.success is not None:
19239 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19240 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19241 
      for iter385 in self.success:
19242 
        iter385.write(oprot)
19243 
      oprot.writeListEnd()
19244 
      oprot.writeFieldEnd()
19245 
    oprot.writeFieldStop()
19246 
    oprot.writeStructEnd()
19247 
 
19248 
  def validate(self):
19249 
    return
19250 
 
19251 
 
19252 
  def __repr__(self):
19253 
    L = ['%s=%r' % (key, value)
19254 
      for key, value in self.__dict__.iteritems()]
19255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19256 
 
19257 
  def __eq__(self, other):
19258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19259 
 
19260 
  def __ne__(self, other):
19261 
    return not (self == other)
8168 kshitij.so 19262 
 
19263 
class updateAmazonAttributesInBulk_args:
19264 
  """
19265 
  Attributes:
19266 
   - amazonlisted
19267 
  """
19268 
 
19269 
  thrift_spec = (
19270 
    None, # 0
19271 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
19272 
  )
19273 
 
19274 
  def __init__(self, amazonlisted=None,):
19275 
    self.amazonlisted = amazonlisted
19276 
 
19277 
  def read(self, iprot):
19278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19280 
      return
19281 
    iprot.readStructBegin()
19282 
    while True:
19283 
      (fname, ftype, fid) = iprot.readFieldBegin()
19284 
      if ftype == TType.STOP:
19285 
        break
19286 
      if fid == 1:
19287 
        if ftype == TType.MAP:
19288 
          self.amazonlisted = {}
19289 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
19290 
          for _i390 in xrange(_size386):
19291 
            _key391 = iprot.readI64();
19292 
            _val392 = Amazonlisted()
19293 
            _val392.read(iprot)
19294 
            self.amazonlisted[_key391] = _val392
19295 
          iprot.readMapEnd()
19296 
        else:
19297 
          iprot.skip(ftype)
19298 
      else:
19299 
        iprot.skip(ftype)
19300 
      iprot.readFieldEnd()
19301 
    iprot.readStructEnd()
19302 
 
19303 
  def write(self, oprot):
19304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19306 
      return
19307 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
19308 
    if self.amazonlisted is not None:
19309 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
19310 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
19311 
      for kiter393,viter394 in self.amazonlisted.items():
19312 
        oprot.writeI64(kiter393)
19313 
        viter394.write(oprot)
19314 
      oprot.writeMapEnd()
19315 
      oprot.writeFieldEnd()
19316 
    oprot.writeFieldStop()
19317 
    oprot.writeStructEnd()
19318 
 
19319 
  def validate(self):
19320 
    return
19321 
 
19322 
 
19323 
  def __repr__(self):
19324 
    L = ['%s=%r' % (key, value)
19325 
      for key, value in self.__dict__.iteritems()]
19326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19327 
 
19328 
  def __eq__(self, other):
19329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19330 
 
19331 
  def __ne__(self, other):
19332 
    return not (self == other)
19333 
 
19334 
class updateAmazonAttributesInBulk_result:
19335 
  """
19336 
  Attributes:
19337 
   - success
19338 
  """
19339 
 
19340 
  thrift_spec = (
19341 
    (0, TType.BOOL, 'success', None, None, ), # 0
19342 
  )
19343 
 
19344 
  def __init__(self, success=None,):
19345 
    self.success = success
19346 
 
19347 
  def read(self, iprot):
19348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19350 
      return
19351 
    iprot.readStructBegin()
19352 
    while True:
19353 
      (fname, ftype, fid) = iprot.readFieldBegin()
19354 
      if ftype == TType.STOP:
19355 
        break
19356 
      if fid == 0:
19357 
        if ftype == TType.BOOL:
19358 
          self.success = iprot.readBool();
19359 
        else:
19360 
          iprot.skip(ftype)
19361 
      else:
19362 
        iprot.skip(ftype)
19363 
      iprot.readFieldEnd()
19364 
    iprot.readStructEnd()
19365 
 
19366 
  def write(self, oprot):
19367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19369 
      return
19370 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
19371 
    if self.success is not None:
19372 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19373 
      oprot.writeBool(self.success)
19374 
      oprot.writeFieldEnd()
19375 
    oprot.writeFieldStop()
19376 
    oprot.writeStructEnd()
19377 
 
19378 
  def validate(self):
19379 
    return
19380 
 
19381 
 
19382 
  def __repr__(self):
19383 
    L = ['%s=%r' % (key, value)
19384 
      for key, value in self.__dict__.iteritems()]
19385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19386 
 
19387 
  def __eq__(self, other):
19388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19389 
 
19390 
  def __ne__(self, other):
19391 
    return not (self == other)