Subversion Repositories SmartDukaan

Rev

Rev 8590 | Rev 8619 | 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 
 
8590 kshitij.so 316 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 317 
    """
8579 kshitij.so 318 
    Banner Related
319 
 
6850 kshitij.so 320 
    Parameters:
8590 kshitij.so 321 
     - bannerCongregate
6850 kshitij.so 322 
    """
323 
    pass
324 
 
8579 kshitij.so 325 
  def updateBanner(self, banner):
326 
    """
327 
    Parameters:
328 
     - banner
329 
    """
330 
    pass
331 
 
6850 kshitij.so 332 
  def getAllBanners(self, ):
333 
    pass
334 
 
335 
  def deleteBanner(self, bannerName):
336 
    """
337 
    Parameters:
338 
     - bannerName
339 
    """
340 
    pass
341 
 
342 
  def getBannerDetails(self, bannerName):
343 
    """
344 
    Parameters:
345 
     - bannerName
346 
    """
347 
    pass
348 
 
349 
  def getActiveBanners(self, ):
350 
    pass
351 
 
8579 kshitij.so 352 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 353 
    """
354 
    Parameters:
8579 kshitij.so 355 
     - bannerMaps
6849 kshitij.so 356 
    """
357 
    pass
358 
 
8579 kshitij.so 359 
  def updateBannerMap(self, bannerMap):
360 
    """
361 
    Parameters:
362 
     - bannerMap
363 
    """
364 
    pass
365 
 
6849 kshitij.so 366 
  def deleteBannerMap(self, bannerName):
367 
    """
368 
    Parameters:
369 
     - bannerName
370 
    """
371 
    pass
372 
 
373 
  def getBannerMapDetails(self, bannerName):
374 
    """
375 
    Parameters:
376 
     - bannerName
377 
    """
378 
    pass
379 
 
8579 kshitij.so 380 
  def addBannerUri(self, bannerUriMappings):
381 
    """
382 
    Parameters:
383 
     - bannerUriMappings
384 
    """
385 
    pass
386 
 
387 
  def getUriMapping(self, bannerName):
388 
    """
389 
    Parameters:
390 
     - bannerName
391 
    """
392 
    pass
393 
 
394 
  def addCampaign(self, campaign):
395 
    """
396 
    Parameters:
397 
     - campaign
398 
    """
399 
    pass
400 
 
401 
  def getCampaigns(self, campaignName):
402 
    """
403 
    Parameters:
404 
     - campaignName
405 
    """
406 
    pass
407 
 
408 
  def deleteCampaign(self, campaignId):
409 
    """
410 
    Parameters:
411 
     - campaignId
412 
    """
413 
    pass
414 
 
415 
  def getAllCampaigns(self, ):
416 
    pass
417 
 
5944 mandeep.dh 418 
  def deleteSimilarItem(self, itemId, catalogItemId):
419 
    """
420 
    Delete similar item.
421 
 
422 
    Parameters:
423 
     - itemId
424 
     - catalogItemId
425 
    """
426 
    pass
427 
 
428 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
429 
    """
430 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
431 
    If yes, returns the itemId else returns 0
432 
 
433 
    Parameters:
434 
     - brand
435 
     - modelNumber
436 
     - modelName
437 
     - color
438 
    """
439 
    pass
440 
 
441 
  def validateRiskyStatus(self, itemId):
442 
    """
443 
    Check wether item is risky and change status if inventory is not available for risky items
444 
 
445 
    Parameters:
446 
     - itemId
447 
    """
448 
    pass
449 
 
450 
  def changeItemRiskyFlag(self, itemId, risky):
451 
    """
452 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
453 
 
454 
    Parameters:
455 
     - itemId
456 
     - risky
457 
    """
458 
    pass
459 
 
460 
  def getItemsByRiskyFlag(self, ):
461 
    """
462 
    Returns list of items marked as risky.
463 
    """
464 
    pass
465 
 
466 
  def getItemsForMasterSheet(self, category, brand):
467 
    """
468 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
469 
 
470 
    Parameters:
471 
     - category
472 
     - brand
473 
    """
474 
    pass
475 
 
476 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
477 
    """
478 
    Returns list of catalog ids of items with same similarity index as of the given itemId
479 
 
480 
    Parameters:
481 
     - beginIndex
482 
     - totalItems
483 
     - itemId
484 
    """
485 
    pass
486 
 
487 
  def addProductNotification(self, itemId, email):
488 
    """
489 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
490 
 
491 
    Parameters:
492 
     - itemId
493 
     - email
494 
    """
495 
    pass
496 
 
497 
  def sendProductNotifications(self, ):
498 
    """
499 
    Send the product notifications to the users for items which has stock.
500 
    """
501 
    pass
502 
 
503 
  def getAllBrandsByCategory(self, categoryId):
504 
    """
505 
    Returns list of brand names for a given category Id
506 
 
507 
    Parameters:
508 
     - categoryId
509 
    """
510 
    pass
511 
 
512 
  def getAllBrands(self, ):
513 
    """
514 
    Returns list of brand names
515 
    """
516 
    pass
517 
 
518 
  def getAllSources(self, ):
519 
    """
520 
    Return list of all sources
521 
    """
522 
    pass
523 
 
524 
  def getItemPricingBySource(self, itemId, sourceId):
525 
    """
526 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
527 
 
528 
    Parameters:
529 
     - itemId
530 
     - sourceId
531 
    """
532 
    pass
533 
 
534 
  def addSourceItemPricing(self, sourceItemPricing):
535 
    """
536 
    Adds prices to be displayed corresponding to the item if user comes from a source.
537 
    If item is not found or source is not found, it will throw exception.
538 
 
539 
    Parameters:
540 
     - sourceItemPricing
541 
    """
542 
    pass
543 
 
544 
  def getAllSourcePricing(self, itemId):
545 
    """
546 
    Returns the list of source pricing information of an item.
547 
    Raises an exception if item not found corresponding to itemId
548 
 
549 
    Parameters:
550 
     - itemId
551 
    """
552 
    pass
553 
 
554 
  def getItemForSource(self, item_id, sourceId):
555 
    """
556 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
557 
 
558 
    Parameters:
559 
     - item_id
560 
     - sourceId
561 
    """
562 
    pass
563 
 
564 
  def searchItemsInRange(self, searchTerms, offset, limit):
565 
    """
566 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
567 
 
568 
    Parameters:
569 
     - searchTerms
570 
     - offset
571 
     - limit
572 
    """
573 
    pass
574 
 
575 
  def getSearchResultCount(self, searchTerms):
576 
    """
577 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
578 
 
579 
    Parameters:
580 
     - searchTerms
581 
    """
582 
    pass
583 
 
584 
  def getProductNotifications(self, startDateTime):
585 
    """
586 
    Returns a list of product notifications added after a supplied datetime
587 
 
588 
    Parameters:
589 
     - startDateTime
590 
    """
591 
    pass
592 
 
7897 amar.kumar 593 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 594 
    """
595 
    Returns a list of count of requests for product notification against each item
596 
 
597 
    Parameters:
598 
     - startDateTime
7897 amar.kumar 599 
     - categoryId
5944 mandeep.dh 600 
    """
601 
    pass
602 
 
603 
  def addAuthorizationLog(self, itemId, username, reason):
604 
    """
605 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
606 
 
607 
    Parameters:
608 
     - itemId
609 
     - username
610 
     - reason
611 
    """
612 
    pass
613 
 
614 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
615 
    """
616 
    Parameters:
617 
     - catalog_item_id
618 
     - voucherType
619 
     - voucherAmount
620 
    """
621 
    pass
622 
 
623 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
624 
    """
625 
    Parameters:
626 
     - catalog_item_id
627 
     - voucherType
628 
    """
629 
    pass
630 
 
631 
  def getVoucherAmount(self, itemId, voucherType):
632 
    """
633 
    Parameters:
634 
     - itemId
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getAllItemVouchers(self, itemId):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
    """
644 
    pass
645 
 
646 
  def isValidCatalogItemId(self, catalog_item_id):
647 
    """
648 
    Parameters:
649 
     - catalog_item_id
650 
    """
651 
    pass
652 
 
7330 amit.gupta 653 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 654 
    """
655 
    Parameters:
656 
     - itemId
7330 amit.gupta 657 
     - stateId
6039 amit.gupta 658 
     - price
659 
    """
660 
    pass
5944 mandeep.dh 661 
 
6039 amit.gupta 662 
  def getVatAmountForItem(self, itemId, price):
663 
    """
664 
    Parameters:
665 
     - itemId
666 
     - price
667 
    """
668 
    pass
669 
 
6531 vikram.rag 670 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
671 
    """
672 
    Parameters:
673 
     - offset
674 
     - limit
675 
    """
676 
    pass
6039 amit.gupta 677 
 
6821 amar.kumar 678 
  def getAllAliveItems(self, ):
679 
    pass
680 
 
6921 anupam.sin 681 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 682 
    """
683 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 684 
 
6805 anupam.sin 685 
    Parameters:
686 
     - itemId
6921 anupam.sin 687 
     - price
6805 anupam.sin 688 
     - insurerId
689 
     - quantity
690 
    """
691 
    pass
692 
 
693 
  def getInsurer(self, insurerId):
694 
    """
695 
    Parameters:
696 
     - insurerId
697 
    """
698 
    pass
699 
 
6838 vikram.rag 700 
  def getAllInsurers(self, ):
701 
    pass
6805 anupam.sin 702 
 
6962 rajveer 703 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
704 
    """
705 
    Parameters:
706 
     - insurerId
707 
     - amount
708 
    """
709 
    pass
6838 vikram.rag 710 
 
7190 amar.kumar 711 
  def getFreebieForItem(self, itemId):
712 
    """
713 
    Parameters:
714 
     - itemId
715 
    """
716 
    pass
6962 rajveer 717 
 
7190 amar.kumar 718 
  def addOrUpdateFreebieForItem(self, freebieItem):
719 
    """
720 
    Parameters:
721 
     - freebieItem
722 
    """
723 
    pass
724 
 
7272 amit.gupta 725 
  def addOrUpdateBrandInfo(self, brandInfo):
726 
    """
727 
    Parameters:
728 
     - brandInfo
729 
    """
730 
    pass
731 
 
732 
  def getBrandInfo(self, ):
733 
    pass
734 
 
7256 rajveer 735 
  def getStorePricing(self, itemId):
736 
    """
737 
    Parameters:
738 
     - itemId
739 
    """
740 
    pass
7190 amar.kumar 741 
 
7306 rajveer 742 
  def getStorePricings(self, itemIds):
743 
    """
744 
    Parameters:
745 
     - itemIds
746 
    """
747 
    pass
748 
 
7382 rajveer 749 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 750 
    """
751 
    Parameters:
752 
     - sp
7382 rajveer 753 
     - allColors
7265 rajveer 754 
    """
755 
    pass
7256 rajveer 756 
 
7281 kshitij.so 757 
  def getAllAmazonListedItems(self, ):
758 
    pass
7265 rajveer 759 
 
7281 kshitij.so 760 
  def getAmazonItemDetails(self, itemId):
761 
    """
762 
    Parameters:
763 
     - itemId
764 
    """
765 
    pass
766 
 
8168 kshitij.so 767 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 768 
    """
769 
    Parameters:
8168 kshitij.so 770 
     - amazonlisted
7281 kshitij.so 771 
    """
772 
    pass
773 
 
774 
  def addAmazonItem(self, amazonlisted):
775 
    """
776 
    Parameters:
777 
     - amazonlisted
778 
    """
779 
    pass
780 
 
7291 vikram.rag 781 
  def getAsinItems(self, ):
782 
    pass
7281 kshitij.so 783 
 
7291 vikram.rag 784 
  def getAllFbaListedItems(self, ):
785 
    pass
786 
 
787 
  def getAllNonFbaListedItems(self, ):
788 
    pass
789 
 
7460 kshitij.so 790 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
791 
    """
792 
    Parameters:
793 
     - itemId
794 
     - holdInventory
795 
     - defaultInventory
796 
    """
797 
    pass
7291 vikram.rag 798 
 
7770 kshitij.so 799 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
800 
    """
801 
    Parameters:
802 
     - type
803 
     - sku
804 
     - timestamp
805 
    """
806 
    pass
7460 kshitij.so 807 
 
7897 amar.kumar 808 
  def getAllParentCategories(self, ):
809 
    pass
7770 kshitij.so 810 
 
7977 kshitij.so 811 
  def addPageViewEvent(self, pageViewEvents):
812 
    """
813 
    Parameters:
814 
     - pageViewEvents
815 
    """
816 
    pass
7897 amar.kumar 817 
 
7977 kshitij.so 818 
  def addCartEvent(self, cartEvents):
819 
    """
820 
    Parameters:
821 
     - cartEvents
822 
    """
823 
    pass
824 
 
8182 amar.kumar 825 
  def addEbayItem(self, ebayItem):
826 
    """
827 
    Parameters:
828 
     - ebayItem
829 
    """
830 
    pass
831 
 
832 
  def getEbayItem(self, listingId):
833 
    """
834 
    Parameters:
835 
     - listingId
836 
    """
837 
    pass
838 
 
839 
  def updateEbayItem(self, ebayItem):
840 
    """
841 
    Parameters:
842 
     - ebayItem
843 
    """
844 
    pass
845 
 
8139 kshitij.so 846 
  def getAmazonListedItems(self, offset, limit):
847 
    """
848 
    Parameters:
849 
     - offset
850 
     - limit
851 
    """
852 
    pass
7977 kshitij.so 853 
 
8168 kshitij.so 854 
  def updateAmazonAttributesInBulk(self, amazonlisted):
855 
    """
856 
    Parameters:
857 
     - amazonlisted
858 
    """
859 
    pass
8139 kshitij.so 860 
 
8379 vikram.rag 861 
  def getAllItemstoListOnFba(self, ):
862 
    pass
8168 kshitij.so 863 
 
8379 vikram.rag 864 
  def getAllItemstoListOnNonFba(self, ):
865 
    pass
866 
 
8616 vikram.rag 867 
  def getAllSnapdealListedActiveItems(self, ):
868 
    pass
8379 vikram.rag 869 
 
8616 vikram.rag 870 
 
5944 mandeep.dh 871 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
872 
  def __init__(self, iprot, oprot=None):
873 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
874 
 
875 
  def addItem(self, item):
876 
    """
877 
    Availability and inventory attributes
878 
 
879 
    Parameters:
880 
     - item
881 
    """
882 
    self.send_addItem(item)
883 
    return self.recv_addItem()
884 
 
885 
  def send_addItem(self, item):
886 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
887 
    args = addItem_args()
888 
    args.item = item
889 
    args.write(self._oprot)
890 
    self._oprot.writeMessageEnd()
891 
    self._oprot.trans.flush()
892 
 
893 
  def recv_addItem(self, ):
894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
895 
    if mtype == TMessageType.EXCEPTION:
896 
      x = TApplicationException()
897 
      x.read(self._iprot)
898 
      self._iprot.readMessageEnd()
899 
      raise x
900 
    result = addItem_result()
901 
    result.read(self._iprot)
902 
    self._iprot.readMessageEnd()
903 
    if result.success is not None:
904 
      return result.success
905 
    if result.cex is not None:
906 
      raise result.cex
907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
908 
 
909 
  def updateItem(self, item):
910 
    """
911 
    Parameters:
912 
     - item
913 
    """
914 
    self.send_updateItem(item)
915 
    return self.recv_updateItem()
916 
 
917 
  def send_updateItem(self, item):
918 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
919 
    args = updateItem_args()
920 
    args.item = item
921 
    args.write(self._oprot)
922 
    self._oprot.writeMessageEnd()
923 
    self._oprot.trans.flush()
924 
 
925 
  def recv_updateItem(self, ):
926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
927 
    if mtype == TMessageType.EXCEPTION:
928 
      x = TApplicationException()
929 
      x.read(self._iprot)
930 
      self._iprot.readMessageEnd()
931 
      raise x
932 
    result = updateItem_result()
933 
    result.read(self._iprot)
934 
    self._iprot.readMessageEnd()
935 
    if result.success is not None:
936 
      return result.success
937 
    if result.cex is not None:
938 
      raise result.cex
939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
940 
 
941 
  def isActive(self, itemId):
942 
    """
943 
    Checks if the item given to the corresponding itemId is active. If it's active,
944 
    whether it's risky and if it's risky, its inventory position.
945 
 
946 
    Parameters:
947 
     - itemId
948 
    """
949 
    self.send_isActive(itemId)
950 
    return self.recv_isActive()
951 
 
952 
  def send_isActive(self, itemId):
953 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
954 
    args = isActive_args()
955 
    args.itemId = itemId
956 
    args.write(self._oprot)
957 
    self._oprot.writeMessageEnd()
958 
    self._oprot.trans.flush()
959 
 
960 
  def recv_isActive(self, ):
961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
962 
    if mtype == TMessageType.EXCEPTION:
963 
      x = TApplicationException()
964 
      x.read(self._iprot)
965 
      self._iprot.readMessageEnd()
966 
      raise x
967 
    result = isActive_result()
968 
    result.read(self._iprot)
969 
    self._iprot.readMessageEnd()
970 
    if result.success is not None:
971 
      return result.success
972 
    if result.isex is not None:
973 
      raise result.isex
974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
975 
 
7438 amit.gupta 976 
  def getItemsStatus(self, itemIds):
977 
    """
978 
    Parameters:
979 
     - itemIds
980 
    """
981 
    self.send_getItemsStatus(itemIds)
982 
    return self.recv_getItemsStatus()
983 
 
984 
  def send_getItemsStatus(self, itemIds):
985 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
986 
    args = getItemsStatus_args()
987 
    args.itemIds = itemIds
988 
    args.write(self._oprot)
989 
    self._oprot.writeMessageEnd()
990 
    self._oprot.trans.flush()
991 
 
992 
  def recv_getItemsStatus(self, ):
993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
994 
    if mtype == TMessageType.EXCEPTION:
995 
      x = TApplicationException()
996 
      x.read(self._iprot)
997 
      self._iprot.readMessageEnd()
998 
      raise x
999 
    result = getItemsStatus_result()
1000 
    result.read(self._iprot)
1001 
    self._iprot.readMessageEnd()
1002 
    if result.success is not None:
1003 
      return result.success
1004 
    if result.isex is not None:
1005 
      raise result.isex
1006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1007 
 
5944 mandeep.dh 1008 
  def getItemStatusDescription(self, itemId):
1009 
    """
1010 
    Parameters:
1011 
     - itemId
1012 
    """
1013 
    self.send_getItemStatusDescription(itemId)
1014 
    return self.recv_getItemStatusDescription()
1015 
 
1016 
  def send_getItemStatusDescription(self, itemId):
1017 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1018 
    args = getItemStatusDescription_args()
1019 
    args.itemId = itemId
1020 
    args.write(self._oprot)
1021 
    self._oprot.writeMessageEnd()
1022 
    self._oprot.trans.flush()
1023 
 
1024 
  def recv_getItemStatusDescription(self, ):
1025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1026 
    if mtype == TMessageType.EXCEPTION:
1027 
      x = TApplicationException()
1028 
      x.read(self._iprot)
1029 
      self._iprot.readMessageEnd()
1030 
      raise x
1031 
    result = getItemStatusDescription_result()
1032 
    result.read(self._iprot)
1033 
    self._iprot.readMessageEnd()
1034 
    if result.success is not None:
1035 
      return result.success
1036 
    if result.isex is not None:
1037 
      raise result.isex
1038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1039 
 
1040 
  def startItemOn(self, item_id, timestamp):
1041 
    """
1042 
    Parameters:
1043 
     - item_id
1044 
     - timestamp
1045 
    """
1046 
    self.send_startItemOn(item_id, timestamp)
1047 
    self.recv_startItemOn()
1048 
 
1049 
  def send_startItemOn(self, item_id, timestamp):
1050 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1051 
    args = startItemOn_args()
1052 
    args.item_id = item_id
1053 
    args.timestamp = timestamp
1054 
    args.write(self._oprot)
1055 
    self._oprot.writeMessageEnd()
1056 
    self._oprot.trans.flush()
1057 
 
1058 
  def recv_startItemOn(self, ):
1059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1060 
    if mtype == TMessageType.EXCEPTION:
1061 
      x = TApplicationException()
1062 
      x.read(self._iprot)
1063 
      self._iprot.readMessageEnd()
1064 
      raise x
1065 
    result = startItemOn_result()
1066 
    result.read(self._iprot)
1067 
    self._iprot.readMessageEnd()
1068 
    if result.cex is not None:
1069 
      raise result.cex
1070 
    return
1071 
 
1072 
  def retireItemOn(self, item_id, timestamp):
1073 
    """
1074 
    Parameters:
1075 
     - item_id
1076 
     - timestamp
1077 
    """
1078 
    self.send_retireItemOn(item_id, timestamp)
1079 
    self.recv_retireItemOn()
1080 
 
1081 
  def send_retireItemOn(self, item_id, timestamp):
1082 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1083 
    args = retireItemOn_args()
1084 
    args.item_id = item_id
1085 
    args.timestamp = timestamp
1086 
    args.write(self._oprot)
1087 
    self._oprot.writeMessageEnd()
1088 
    self._oprot.trans.flush()
1089 
 
1090 
  def recv_retireItemOn(self, ):
1091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1092 
    if mtype == TMessageType.EXCEPTION:
1093 
      x = TApplicationException()
1094 
      x.read(self._iprot)
1095 
      self._iprot.readMessageEnd()
1096 
      raise x
1097 
    result = retireItemOn_result()
1098 
    result.read(self._iprot)
1099 
    self._iprot.readMessageEnd()
1100 
    if result.cex is not None:
1101 
      raise result.cex
1102 
    return
1103 
 
1104 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1105 
    """
1106 
    Parameters:
1107 
     - item_id
1108 
     - timestamp
1109 
     - newstatus
1110 
    """
1111 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1112 
    self.recv_changeItemStatus()
1113 
 
1114 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1115 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1116 
    args = changeItemStatus_args()
1117 
    args.item_id = item_id
1118 
    args.timestamp = timestamp
1119 
    args.newstatus = newstatus
1120 
    args.write(self._oprot)
1121 
    self._oprot.writeMessageEnd()
1122 
    self._oprot.trans.flush()
1123 
 
1124 
  def recv_changeItemStatus(self, ):
1125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1126 
    if mtype == TMessageType.EXCEPTION:
1127 
      x = TApplicationException()
1128 
      x.read(self._iprot)
1129 
      self._iprot.readMessageEnd()
1130 
      raise x
1131 
    result = changeItemStatus_result()
1132 
    result.read(self._iprot)
1133 
    self._iprot.readMessageEnd()
1134 
    if result.cex is not None:
1135 
      raise result.cex
1136 
    return
1137 
 
1138 
  def getItem(self, item_id):
1139 
    """
1140 
    Parameters:
1141 
     - item_id
1142 
    """
1143 
    self.send_getItem(item_id)
1144 
    return self.recv_getItem()
1145 
 
1146 
  def send_getItem(self, item_id):
1147 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1148 
    args = getItem_args()
1149 
    args.item_id = item_id
1150 
    args.write(self._oprot)
1151 
    self._oprot.writeMessageEnd()
1152 
    self._oprot.trans.flush()
1153 
 
1154 
  def recv_getItem(self, ):
1155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1156 
    if mtype == TMessageType.EXCEPTION:
1157 
      x = TApplicationException()
1158 
      x.read(self._iprot)
1159 
      self._iprot.readMessageEnd()
1160 
      raise x
1161 
    result = getItem_result()
1162 
    result.read(self._iprot)
1163 
    self._iprot.readMessageEnd()
1164 
    if result.success is not None:
1165 
      return result.success
1166 
    if result.cex is not None:
1167 
      raise result.cex
1168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1169 
 
1170 
  def getItemsByCatalogId(self, catalog_item_id):
1171 
    """
1172 
    Parameters:
1173 
     - catalog_item_id
1174 
    """
1175 
    self.send_getItemsByCatalogId(catalog_item_id)
1176 
    return self.recv_getItemsByCatalogId()
1177 
 
1178 
  def send_getItemsByCatalogId(self, catalog_item_id):
1179 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1180 
    args = getItemsByCatalogId_args()
1181 
    args.catalog_item_id = catalog_item_id
1182 
    args.write(self._oprot)
1183 
    self._oprot.writeMessageEnd()
1184 
    self._oprot.trans.flush()
1185 
 
1186 
  def recv_getItemsByCatalogId(self, ):
1187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1188 
    if mtype == TMessageType.EXCEPTION:
1189 
      x = TApplicationException()
1190 
      x.read(self._iprot)
1191 
      self._iprot.readMessageEnd()
1192 
      raise x
1193 
    result = getItemsByCatalogId_result()
1194 
    result.read(self._iprot)
1195 
    self._iprot.readMessageEnd()
1196 
    if result.success is not None:
1197 
      return result.success
1198 
    if result.cex is not None:
1199 
      raise result.cex
1200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1201 
 
1202 
  def getValidItemsByCatalogId(self, catalog_item_id):
1203 
    """
1204 
    Parameters:
1205 
     - catalog_item_id
1206 
    """
1207 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1208 
    return self.recv_getValidItemsByCatalogId()
1209 
 
1210 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1211 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1212 
    args = getValidItemsByCatalogId_args()
1213 
    args.catalog_item_id = catalog_item_id
1214 
    args.write(self._oprot)
1215 
    self._oprot.writeMessageEnd()
1216 
    self._oprot.trans.flush()
1217 
 
1218 
  def recv_getValidItemsByCatalogId(self, ):
1219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1220 
    if mtype == TMessageType.EXCEPTION:
1221 
      x = TApplicationException()
1222 
      x.read(self._iprot)
1223 
      self._iprot.readMessageEnd()
1224 
      raise x
1225 
    result = getValidItemsByCatalogId_result()
1226 
    result.read(self._iprot)
1227 
    self._iprot.readMessageEnd()
1228 
    if result.success is not None:
1229 
      return result.success
1230 
    if result.cex is not None:
1231 
      raise result.cex
1232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1233 
 
1234 
  def getAllItems(self, isActive):
1235 
    """
1236 
    Parameters:
1237 
     - isActive
1238 
    """
1239 
    self.send_getAllItems(isActive)
1240 
    return self.recv_getAllItems()
1241 
 
1242 
  def send_getAllItems(self, isActive):
1243 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1244 
    args = getAllItems_args()
1245 
    args.isActive = isActive
1246 
    args.write(self._oprot)
1247 
    self._oprot.writeMessageEnd()
1248 
    self._oprot.trans.flush()
1249 
 
1250 
  def recv_getAllItems(self, ):
1251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1252 
    if mtype == TMessageType.EXCEPTION:
1253 
      x = TApplicationException()
1254 
      x.read(self._iprot)
1255 
      self._iprot.readMessageEnd()
1256 
      raise x
1257 
    result = getAllItems_result()
1258 
    result.read(self._iprot)
1259 
    self._iprot.readMessageEnd()
1260 
    if result.success is not None:
1261 
      return result.success
1262 
    if result.cex is not None:
1263 
      raise result.cex
1264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1265 
 
1266 
  def getAllItemsByStatus(self, itemStatus):
1267 
    """
1268 
    Parameters:
1269 
     - itemStatus
1270 
    """
1271 
    self.send_getAllItemsByStatus(itemStatus)
1272 
    return self.recv_getAllItemsByStatus()
1273 
 
1274 
  def send_getAllItemsByStatus(self, itemStatus):
1275 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1276 
    args = getAllItemsByStatus_args()
1277 
    args.itemStatus = itemStatus
1278 
    args.write(self._oprot)
1279 
    self._oprot.writeMessageEnd()
1280 
    self._oprot.trans.flush()
1281 
 
1282 
  def recv_getAllItemsByStatus(self, ):
1283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1284 
    if mtype == TMessageType.EXCEPTION:
1285 
      x = TApplicationException()
1286 
      x.read(self._iprot)
1287 
      self._iprot.readMessageEnd()
1288 
      raise x
1289 
    result = getAllItemsByStatus_result()
1290 
    result.read(self._iprot)
1291 
    self._iprot.readMessageEnd()
1292 
    if result.success is not None:
1293 
      return result.success
1294 
    if result.cex is not None:
1295 
      raise result.cex
1296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1297 
 
1298 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1299 
    """
1300 
    Parameters:
1301 
     - entityId
1302 
     - category
1303 
     - brand
1304 
     - modelName
1305 
     - modelNumber
1306 
    """
1307 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1308 
    return self.recv_markItemAsContentComplete()
1309 
 
1310 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1311 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1312 
    args = markItemAsContentComplete_args()
1313 
    args.entityId = entityId
1314 
    args.category = category
1315 
    args.brand = brand
1316 
    args.modelName = modelName
1317 
    args.modelNumber = modelNumber
1318 
    args.write(self._oprot)
1319 
    self._oprot.writeMessageEnd()
1320 
    self._oprot.trans.flush()
1321 
 
1322 
  def recv_markItemAsContentComplete(self, ):
1323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1324 
    if mtype == TMessageType.EXCEPTION:
1325 
      x = TApplicationException()
1326 
      x.read(self._iprot)
1327 
      self._iprot.readMessageEnd()
1328 
      raise x
1329 
    result = markItemAsContentComplete_result()
1330 
    result.read(self._iprot)
1331 
    self._iprot.readMessageEnd()
1332 
    if result.success is not None:
1333 
      return result.success
1334 
    if result.cex is not None:
1335 
      raise result.cex
1336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1337 
 
1338 
  def getAllItemsInRange(self, offset, limit):
1339 
    """
1340 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1341 
 
1342 
    Parameters:
1343 
     - offset
1344 
     - limit
1345 
    """
1346 
    self.send_getAllItemsInRange(offset, limit)
1347 
    return self.recv_getAllItemsInRange()
1348 
 
1349 
  def send_getAllItemsInRange(self, offset, limit):
1350 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1351 
    args = getAllItemsInRange_args()
1352 
    args.offset = offset
1353 
    args.limit = limit
1354 
    args.write(self._oprot)
1355 
    self._oprot.writeMessageEnd()
1356 
    self._oprot.trans.flush()
1357 
 
1358 
  def recv_getAllItemsInRange(self, ):
1359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1360 
    if mtype == TMessageType.EXCEPTION:
1361 
      x = TApplicationException()
1362 
      x.read(self._iprot)
1363 
      self._iprot.readMessageEnd()
1364 
      raise x
1365 
    result = getAllItemsInRange_result()
1366 
    result.read(self._iprot)
1367 
    self._iprot.readMessageEnd()
1368 
    if result.success is not None:
1369 
      return result.success
1370 
    if result.cex is not None:
1371 
      raise result.cex
1372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1373 
 
1374 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1375 
    """
1376 
    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.
1377 
 
1378 
    Parameters:
1379 
     - itemStatus
1380 
     - offset
1381 
     - limit
1382 
    """
1383 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1384 
    return self.recv_getAllItemsByStatusInRange()
1385 
 
1386 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1387 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1388 
    args = getAllItemsByStatusInRange_args()
1389 
    args.itemStatus = itemStatus
1390 
    args.offset = offset
1391 
    args.limit = limit
1392 
    args.write(self._oprot)
1393 
    self._oprot.writeMessageEnd()
1394 
    self._oprot.trans.flush()
1395 
 
1396 
  def recv_getAllItemsByStatusInRange(self, ):
1397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1398 
    if mtype == TMessageType.EXCEPTION:
1399 
      x = TApplicationException()
1400 
      x.read(self._iprot)
1401 
      self._iprot.readMessageEnd()
1402 
      raise x
1403 
    result = getAllItemsByStatusInRange_result()
1404 
    result.read(self._iprot)
1405 
    self._iprot.readMessageEnd()
1406 
    if result.success is not None:
1407 
      return result.success
1408 
    if result.cex is not None:
1409 
      raise result.cex
1410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1411 
 
1412 
  def getItemCountByStatus(self, useStatus, itemStatus):
1413 
    """
1414 
    Gets a count of all items by status
1415 
 
1416 
    Parameters:
1417 
     - useStatus
1418 
     - itemStatus
1419 
    """
1420 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1421 
    return self.recv_getItemCountByStatus()
1422 
 
1423 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1424 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1425 
    args = getItemCountByStatus_args()
1426 
    args.useStatus = useStatus
1427 
    args.itemStatus = itemStatus
1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
1432 
  def recv_getItemCountByStatus(self, ):
1433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1434 
    if mtype == TMessageType.EXCEPTION:
1435 
      x = TApplicationException()
1436 
      x.read(self._iprot)
1437 
      self._iprot.readMessageEnd()
1438 
      raise x
1439 
    result = getItemCountByStatus_result()
1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
1442 
    if result.success is not None:
1443 
      return result.success
1444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1445 
 
1446 
  def getBestSellers(self, ):
1447 
    self.send_getBestSellers()
1448 
    return self.recv_getBestSellers()
1449 
 
1450 
  def send_getBestSellers(self, ):
1451 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1452 
    args = getBestSellers_args()
1453 
    args.write(self._oprot)
1454 
    self._oprot.writeMessageEnd()
1455 
    self._oprot.trans.flush()
1456 
 
1457 
  def recv_getBestSellers(self, ):
1458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1459 
    if mtype == TMessageType.EXCEPTION:
1460 
      x = TApplicationException()
1461 
      x.read(self._iprot)
1462 
      self._iprot.readMessageEnd()
1463 
      raise x
1464 
    result = getBestSellers_result()
1465 
    result.read(self._iprot)
1466 
    self._iprot.readMessageEnd()
1467 
    if result.success is not None:
1468 
      return result.success
1469 
    if result.isex is not None:
1470 
      raise result.isex
1471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1472 
 
1473 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1474 
    """
1475 
    Parameters:
1476 
     - beginIndex
1477 
     - totalItems
1478 
     - brand
1479 
     - category
1480 
    """
1481 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1482 
    return self.recv_getBestSellersCatalogIds()
1483 
 
1484 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1485 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1486 
    args = getBestSellersCatalogIds_args()
1487 
    args.beginIndex = beginIndex
1488 
    args.totalItems = totalItems
1489 
    args.brand = brand
1490 
    args.category = category
1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
1495 
  def recv_getBestSellersCatalogIds(self, ):
1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
1502 
    result = getBestSellersCatalogIds_result()
1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
1505 
    if result.success is not None:
1506 
      return result.success
1507 
    if result.cex is not None:
1508 
      raise result.cex
1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1510 
 
1511 
  def getBestSellersCount(self, ):
1512 
    self.send_getBestSellersCount()
1513 
    return self.recv_getBestSellersCount()
1514 
 
1515 
  def send_getBestSellersCount(self, ):
1516 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1517 
    args = getBestSellersCount_args()
1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_getBestSellersCount(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = getBestSellersCount_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
1532 
    if result.success is not None:
1533 
      return result.success
1534 
    if result.cex is not None:
1535 
      raise result.cex
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1537 
 
1538 
  def getBestDeals(self, ):
1539 
    self.send_getBestDeals()
1540 
    return self.recv_getBestDeals()
1541 
 
1542 
  def send_getBestDeals(self, ):
1543 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1544 
    args = getBestDeals_args()
1545 
    args.write(self._oprot)
1546 
    self._oprot.writeMessageEnd()
1547 
    self._oprot.trans.flush()
1548 
 
1549 
  def recv_getBestDeals(self, ):
1550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1551 
    if mtype == TMessageType.EXCEPTION:
1552 
      x = TApplicationException()
1553 
      x.read(self._iprot)
1554 
      self._iprot.readMessageEnd()
1555 
      raise x
1556 
    result = getBestDeals_result()
1557 
    result.read(self._iprot)
1558 
    self._iprot.readMessageEnd()
1559 
    if result.success is not None:
1560 
      return result.success
1561 
    if result.isex is not None:
1562 
      raise result.isex
1563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1564 
 
1565 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1566 
    """
1567 
    Parameters:
1568 
     - beginIndex
1569 
     - totalItems
1570 
     - brand
1571 
     - category
1572 
    """
1573 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1574 
    return self.recv_getBestDealsCatalogIds()
1575 
 
1576 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1577 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1578 
    args = getBestDealsCatalogIds_args()
1579 
    args.beginIndex = beginIndex
1580 
    args.totalItems = totalItems
1581 
    args.brand = brand
1582 
    args.category = category
1583 
    args.write(self._oprot)
1584 
    self._oprot.writeMessageEnd()
1585 
    self._oprot.trans.flush()
1586 
 
1587 
  def recv_getBestDealsCatalogIds(self, ):
1588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1589 
    if mtype == TMessageType.EXCEPTION:
1590 
      x = TApplicationException()
1591 
      x.read(self._iprot)
1592 
      self._iprot.readMessageEnd()
1593 
      raise x
1594 
    result = getBestDealsCatalogIds_result()
1595 
    result.read(self._iprot)
1596 
    self._iprot.readMessageEnd()
1597 
    if result.success is not None:
1598 
      return result.success
1599 
    if result.cex is not None:
1600 
      raise result.cex
1601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1602 
 
1603 
  def getBestDealsCount(self, ):
1604 
    self.send_getBestDealsCount()
1605 
    return self.recv_getBestDealsCount()
1606 
 
1607 
  def send_getBestDealsCount(self, ):
1608 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1609 
    args = getBestDealsCount_args()
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_getBestDealsCount(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = getBestDealsCount_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
1624 
    if result.success is not None:
1625 
      return result.success
1626 
    if result.cex is not None:
1627 
      raise result.cex
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1629 
 
1630 
  def getComingSoon(self, ):
1631 
    self.send_getComingSoon()
1632 
    return self.recv_getComingSoon()
1633 
 
1634 
  def send_getComingSoon(self, ):
1635 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1636 
    args = getComingSoon_args()
1637 
    args.write(self._oprot)
1638 
    self._oprot.writeMessageEnd()
1639 
    self._oprot.trans.flush()
1640 
 
1641 
  def recv_getComingSoon(self, ):
1642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1643 
    if mtype == TMessageType.EXCEPTION:
1644 
      x = TApplicationException()
1645 
      x.read(self._iprot)
1646 
      self._iprot.readMessageEnd()
1647 
      raise x
1648 
    result = getComingSoon_result()
1649 
    result.read(self._iprot)
1650 
    self._iprot.readMessageEnd()
1651 
    if result.success is not None:
1652 
      return result.success
1653 
    if result.isex is not None:
1654 
      raise result.isex
1655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1656 
 
1657 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1658 
    """
1659 
    Parameters:
1660 
     - beginIndex
1661 
     - totalItems
1662 
     - brand
1663 
     - category
1664 
    """
1665 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1666 
    return self.recv_getComingSoonCatalogIds()
1667 
 
1668 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1669 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1670 
    args = getComingSoonCatalogIds_args()
1671 
    args.beginIndex = beginIndex
1672 
    args.totalItems = totalItems
1673 
    args.brand = brand
1674 
    args.category = category
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getComingSoonCatalogIds(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = getComingSoonCatalogIds_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
1689 
    if result.success is not None:
1690 
      return result.success
1691 
    if result.cex is not None:
1692 
      raise result.cex
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1694 
 
1695 
  def getComingSoonCount(self, ):
1696 
    self.send_getComingSoonCount()
1697 
    return self.recv_getComingSoonCount()
1698 
 
1699 
  def send_getComingSoonCount(self, ):
1700 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1701 
    args = getComingSoonCount_args()
1702 
    args.write(self._oprot)
1703 
    self._oprot.writeMessageEnd()
1704 
    self._oprot.trans.flush()
1705 
 
1706 
  def recv_getComingSoonCount(self, ):
1707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1708 
    if mtype == TMessageType.EXCEPTION:
1709 
      x = TApplicationException()
1710 
      x.read(self._iprot)
1711 
      self._iprot.readMessageEnd()
1712 
      raise x
1713 
    result = getComingSoonCount_result()
1714 
    result.read(self._iprot)
1715 
    self._iprot.readMessageEnd()
1716 
    if result.success is not None:
1717 
      return result.success
1718 
    if result.cex is not None:
1719 
      raise result.cex
1720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1721 
 
1722 
  def getLatestArrivals(self, ):
1723 
    """
1724 
    Returns a list of items sorted in the descending order by start date.
1725 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1726 
    """
1727 
    self.send_getLatestArrivals()
1728 
    return self.recv_getLatestArrivals()
1729 
 
1730 
  def send_getLatestArrivals(self, ):
1731 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1732 
    args = getLatestArrivals_args()
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getLatestArrivals(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getLatestArrivals_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
1747 
    if result.success is not None:
1748 
      return result.success
1749 
    if result.isex is not None:
1750 
      raise result.isex
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1752 
 
1753 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1754 
    """
1755 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1756 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1757 
 
1758 
    Parameters:
1759 
     - beginIndex
1760 
     - totalItems
1761 
     - brand
1762 
     - categories
1763 
    """
1764 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1765 
    return self.recv_getLatestArrivalsCatalogIds()
1766 
 
1767 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1768 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1769 
    args = getLatestArrivalsCatalogIds_args()
1770 
    args.beginIndex = beginIndex
1771 
    args.totalItems = totalItems
1772 
    args.brand = brand
1773 
    args.categories = categories
1774 
    args.write(self._oprot)
1775 
    self._oprot.writeMessageEnd()
1776 
    self._oprot.trans.flush()
1777 
 
1778 
  def recv_getLatestArrivalsCatalogIds(self, ):
1779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1780 
    if mtype == TMessageType.EXCEPTION:
1781 
      x = TApplicationException()
1782 
      x.read(self._iprot)
1783 
      self._iprot.readMessageEnd()
1784 
      raise x
1785 
    result = getLatestArrivalsCatalogIds_result()
1786 
    result.read(self._iprot)
1787 
    self._iprot.readMessageEnd()
1788 
    if result.success is not None:
1789 
      return result.success
1790 
    if result.cex is not None:
1791 
      raise result.cex
1792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1793 
 
1794 
  def getLatestArrivalsCount(self, ):
1795 
    """
1796 
    Get the total number of latest arrivals we are willing to show.
1797 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1798 
    """
1799 
    self.send_getLatestArrivalsCount()
1800 
    return self.recv_getLatestArrivalsCount()
1801 
 
1802 
  def send_getLatestArrivalsCount(self, ):
1803 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1804 
    args = getLatestArrivalsCount_args()
1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
1809 
  def recv_getLatestArrivalsCount(self, ):
1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
1816 
    result = getLatestArrivalsCount_result()
1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
1819 
    if result.success is not None:
1820 
      return result.success
1821 
    if result.cex is not None:
1822 
      raise result.cex
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1824 
 
1825 
  def generateNewEntityID(self, ):
1826 
    self.send_generateNewEntityID()
1827 
    return self.recv_generateNewEntityID()
1828 
 
1829 
  def send_generateNewEntityID(self, ):
1830 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1831 
    args = generateNewEntityID_args()
1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
1836 
  def recv_generateNewEntityID(self, ):
1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
1843 
    result = generateNewEntityID_result()
1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
1846 
    if result.success is not None:
1847 
      return result.success
1848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1849 
 
1850 
  def addCategory(self, category):
1851 
    """
1852 
    All category related functions
1853 
 
1854 
    Parameters:
1855 
     - category
1856 
    """
1857 
    self.send_addCategory(category)
1858 
    return self.recv_addCategory()
1859 
 
1860 
  def send_addCategory(self, category):
1861 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1862 
    args = addCategory_args()
1863 
    args.category = category
1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
1868 
  def recv_addCategory(self, ):
1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
1875 
    result = addCategory_result()
1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
1878 
    if result.success is not None:
1879 
      return result.success
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1881 
 
1882 
  def getCategory(self, id):
1883 
    """
1884 
    Parameters:
1885 
     - id
1886 
    """
1887 
    self.send_getCategory(id)
1888 
    return self.recv_getCategory()
1889 
 
1890 
  def send_getCategory(self, id):
1891 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1892 
    args = getCategory_args()
1893 
    args.id = id
1894 
    args.write(self._oprot)
1895 
    self._oprot.writeMessageEnd()
1896 
    self._oprot.trans.flush()
1897 
 
1898 
  def recv_getCategory(self, ):
1899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1900 
    if mtype == TMessageType.EXCEPTION:
1901 
      x = TApplicationException()
1902 
      x.read(self._iprot)
1903 
      self._iprot.readMessageEnd()
1904 
      raise x
1905 
    result = getCategory_result()
1906 
    result.read(self._iprot)
1907 
    self._iprot.readMessageEnd()
1908 
    if result.success is not None:
1909 
      return result.success
1910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1911 
 
1912 
  def getAllCategories(self, ):
1913 
    self.send_getAllCategories()
1914 
    return self.recv_getAllCategories()
1915 
 
1916 
  def send_getAllCategories(self, ):
1917 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1918 
    args = getAllCategories_args()
1919 
    args.write(self._oprot)
1920 
    self._oprot.writeMessageEnd()
1921 
    self._oprot.trans.flush()
1922 
 
1923 
  def recv_getAllCategories(self, ):
1924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1925 
    if mtype == TMessageType.EXCEPTION:
1926 
      x = TApplicationException()
1927 
      x.read(self._iprot)
1928 
      self._iprot.readMessageEnd()
1929 
      raise x
1930 
    result = getAllCategories_result()
1931 
    result.read(self._iprot)
1932 
    self._iprot.readMessageEnd()
1933 
    if result.success is not None:
1934 
      return result.success
1935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1936 
 
1937 
  def getAllSimilarItems(self, itemId):
1938 
    """
1939 
    Returns the list of similar items.
1940 
 
1941 
    Parameters:
1942 
     - itemId
1943 
    """
1944 
    self.send_getAllSimilarItems(itemId)
1945 
    return self.recv_getAllSimilarItems()
1946 
 
1947 
  def send_getAllSimilarItems(self, itemId):
1948 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1949 
    args = getAllSimilarItems_args()
1950 
    args.itemId = itemId
1951 
    args.write(self._oprot)
1952 
    self._oprot.writeMessageEnd()
1953 
    self._oprot.trans.flush()
1954 
 
1955 
  def recv_getAllSimilarItems(self, ):
1956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1957 
    if mtype == TMessageType.EXCEPTION:
1958 
      x = TApplicationException()
1959 
      x.read(self._iprot)
1960 
      self._iprot.readMessageEnd()
1961 
      raise x
1962 
    result = getAllSimilarItems_result()
1963 
    result.read(self._iprot)
1964 
    self._iprot.readMessageEnd()
1965 
    if result.success is not None:
1966 
      return result.success
1967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1968 
 
1969 
  def addSimilarItem(self, itemId, catalogItemId):
1970 
    """
1971 
    Adds similar item.
1972 
 
1973 
    Parameters:
1974 
     - itemId
1975 
     - catalogItemId
1976 
    """
1977 
    self.send_addSimilarItem(itemId, catalogItemId)
1978 
    return self.recv_addSimilarItem()
1979 
 
1980 
  def send_addSimilarItem(self, itemId, catalogItemId):
1981 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1982 
    args = addSimilarItem_args()
1983 
    args.itemId = itemId
1984 
    args.catalogItemId = catalogItemId
1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
1989 
  def recv_addSimilarItem(self, ):
1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
1996 
    result = addSimilarItem_result()
1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
1999 
    if result.success is not None:
2000 
      return result.success
2001 
    if result.cex is not None:
2002 
      raise result.cex
2003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2004 
 
6512 kshitij.so 2005 
  def addTag(self, displayName, itemId):
2006 
    """
2007 
    Tag Related
2008 
 
2009 
    Parameters:
2010 
     - displayName
2011 
     - itemId
2012 
    """
2013 
    self.send_addTag(displayName, itemId)
2014 
    return self.recv_addTag()
2015 
 
2016 
  def send_addTag(self, displayName, itemId):
2017 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2018 
    args = addTag_args()
2019 
    args.displayName = displayName
2020 
    args.itemId = itemId
2021 
    args.write(self._oprot)
2022 
    self._oprot.writeMessageEnd()
2023 
    self._oprot.trans.flush()
2024 
 
2025 
  def recv_addTag(self, ):
2026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2027 
    if mtype == TMessageType.EXCEPTION:
2028 
      x = TApplicationException()
2029 
      x.read(self._iprot)
2030 
      self._iprot.readMessageEnd()
2031 
      raise x
2032 
    result = addTag_result()
2033 
    result.read(self._iprot)
2034 
    self._iprot.readMessageEnd()
2035 
    if result.success is not None:
2036 
      return result.success
2037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2038 
 
2039 
  def deleteEntityTag(self, displayName, itemId):
2040 
    """
2041 
    Parameters:
2042 
     - displayName
2043 
     - itemId
2044 
    """
2045 
    self.send_deleteEntityTag(displayName, itemId)
2046 
    return self.recv_deleteEntityTag()
2047 
 
2048 
  def send_deleteEntityTag(self, displayName, itemId):
2049 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2050 
    args = deleteEntityTag_args()
2051 
    args.displayName = displayName
2052 
    args.itemId = itemId
2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
2057 
  def recv_deleteEntityTag(self, ):
2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
2064 
    result = deleteEntityTag_result()
2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
2067 
    if result.success is not None:
2068 
      return result.success
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2070 
 
2071 
  def deleteTag(self, displayName):
2072 
    """
2073 
    Parameters:
2074 
     - displayName
2075 
    """
2076 
    self.send_deleteTag(displayName)
2077 
    return self.recv_deleteTag()
2078 
 
2079 
  def send_deleteTag(self, displayName):
2080 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2081 
    args = deleteTag_args()
2082 
    args.displayName = displayName
2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
2087 
  def recv_deleteTag(self, ):
2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
2094 
    result = deleteTag_result()
2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
2097 
    if result.success is not None:
2098 
      return result.success
2099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2100 
 
2101 
  def getAllTags(self, ):
2102 
    self.send_getAllTags()
2103 
    return self.recv_getAllTags()
2104 
 
2105 
  def send_getAllTags(self, ):
2106 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2107 
    args = getAllTags_args()
2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
2112 
  def recv_getAllTags(self, ):
2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
2119 
    result = getAllTags_result()
2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
2122 
    if result.success is not None:
2123 
      return result.success
2124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2125 
 
2126 
  def getAllEntitiesByTagName(self, displayName):
2127 
    """
2128 
    Parameters:
2129 
     - displayName
2130 
    """
2131 
    self.send_getAllEntitiesByTagName(displayName)
2132 
    return self.recv_getAllEntitiesByTagName()
2133 
 
2134 
  def send_getAllEntitiesByTagName(self, displayName):
2135 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2136 
    args = getAllEntitiesByTagName_args()
2137 
    args.displayName = displayName
2138 
    args.write(self._oprot)
2139 
    self._oprot.writeMessageEnd()
2140 
    self._oprot.trans.flush()
2141 
 
2142 
  def recv_getAllEntitiesByTagName(self, ):
2143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2144 
    if mtype == TMessageType.EXCEPTION:
2145 
      x = TApplicationException()
2146 
      x.read(self._iprot)
2147 
      self._iprot.readMessageEnd()
2148 
      raise x
2149 
    result = getAllEntitiesByTagName_result()
2150 
    result.read(self._iprot)
2151 
    self._iprot.readMessageEnd()
2152 
    if result.success is not None:
2153 
      return result.success
2154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2155 
 
6845 amit.gupta 2156 
  def getAllEntityTags(self, ):
2157 
    self.send_getAllEntityTags()
2158 
    return self.recv_getAllEntityTags()
2159 
 
2160 
  def send_getAllEntityTags(self, ):
2161 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2162 
    args = getAllEntityTags_args()
2163 
    args.write(self._oprot)
2164 
    self._oprot.writeMessageEnd()
2165 
    self._oprot.trans.flush()
2166 
 
2167 
  def recv_getAllEntityTags(self, ):
2168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2169 
    if mtype == TMessageType.EXCEPTION:
2170 
      x = TApplicationException()
2171 
      x.read(self._iprot)
2172 
      self._iprot.readMessageEnd()
2173 
      raise x
2174 
    result = getAllEntityTags_result()
2175 
    result.read(self._iprot)
2176 
    self._iprot.readMessageEnd()
2177 
    if result.success is not None:
2178 
      return result.success
2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2180 
 
8590 kshitij.so 2181 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2182 
    """
8579 kshitij.so 2183 
    Banner Related
2184 
 
6850 kshitij.so 2185 
    Parameters:
8590 kshitij.so 2186 
     - bannerCongregate
6850 kshitij.so 2187 
    """
8590 kshitij.so 2188 
    self.send_addBanner(bannerCongregate)
2189 
    self.recv_addBanner()
6850 kshitij.so 2190 
 
8590 kshitij.so 2191 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2192 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2193 
    args = addBanner_args()
8590 kshitij.so 2194 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2195 
    args.write(self._oprot)
2196 
    self._oprot.writeMessageEnd()
2197 
    self._oprot.trans.flush()
2198 
 
2199 
  def recv_addBanner(self, ):
2200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2201 
    if mtype == TMessageType.EXCEPTION:
2202 
      x = TApplicationException()
2203 
      x.read(self._iprot)
2204 
      self._iprot.readMessageEnd()
2205 
      raise x
2206 
    result = addBanner_result()
2207 
    result.read(self._iprot)
2208 
    self._iprot.readMessageEnd()
8590 kshitij.so 2209 
    return
6850 kshitij.so 2210 
 
8579 kshitij.so 2211 
  def updateBanner(self, banner):
2212 
    """
2213 
    Parameters:
2214 
     - banner
2215 
    """
2216 
    self.send_updateBanner(banner)
2217 
    return self.recv_updateBanner()
2218 
 
2219 
  def send_updateBanner(self, banner):
2220 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2221 
    args = updateBanner_args()
2222 
    args.banner = banner
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_updateBanner(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = updateBanner_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
2237 
    if result.success is not None:
2238 
      return result.success
2239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2240 
 
6850 kshitij.so 2241 
  def getAllBanners(self, ):
2242 
    self.send_getAllBanners()
2243 
    return self.recv_getAllBanners()
2244 
 
2245 
  def send_getAllBanners(self, ):
2246 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2247 
    args = getAllBanners_args()
2248 
    args.write(self._oprot)
2249 
    self._oprot.writeMessageEnd()
2250 
    self._oprot.trans.flush()
2251 
 
2252 
  def recv_getAllBanners(self, ):
2253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2254 
    if mtype == TMessageType.EXCEPTION:
2255 
      x = TApplicationException()
2256 
      x.read(self._iprot)
2257 
      self._iprot.readMessageEnd()
2258 
      raise x
2259 
    result = getAllBanners_result()
2260 
    result.read(self._iprot)
2261 
    self._iprot.readMessageEnd()
2262 
    if result.success is not None:
2263 
      return result.success
2264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2265 
 
2266 
  def deleteBanner(self, bannerName):
2267 
    """
2268 
    Parameters:
2269 
     - bannerName
2270 
    """
2271 
    self.send_deleteBanner(bannerName)
2272 
    return self.recv_deleteBanner()
2273 
 
2274 
  def send_deleteBanner(self, bannerName):
2275 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2276 
    args = deleteBanner_args()
2277 
    args.bannerName = bannerName
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_deleteBanner(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = deleteBanner_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
2292 
    if result.success is not None:
2293 
      return result.success
2294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2295 
 
2296 
  def getBannerDetails(self, bannerName):
2297 
    """
2298 
    Parameters:
2299 
     - bannerName
2300 
    """
2301 
    self.send_getBannerDetails(bannerName)
2302 
    return self.recv_getBannerDetails()
2303 
 
2304 
  def send_getBannerDetails(self, bannerName):
2305 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2306 
    args = getBannerDetails_args()
2307 
    args.bannerName = bannerName
2308 
    args.write(self._oprot)
2309 
    self._oprot.writeMessageEnd()
2310 
    self._oprot.trans.flush()
2311 
 
2312 
  def recv_getBannerDetails(self, ):
2313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2314 
    if mtype == TMessageType.EXCEPTION:
2315 
      x = TApplicationException()
2316 
      x.read(self._iprot)
2317 
      self._iprot.readMessageEnd()
2318 
      raise x
2319 
    result = getBannerDetails_result()
2320 
    result.read(self._iprot)
2321 
    self._iprot.readMessageEnd()
2322 
    if result.success is not None:
2323 
      return result.success
2324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2325 
 
2326 
  def getActiveBanners(self, ):
2327 
    self.send_getActiveBanners()
2328 
    return self.recv_getActiveBanners()
2329 
 
2330 
  def send_getActiveBanners(self, ):
2331 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2332 
    args = getActiveBanners_args()
2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_getActiveBanners(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = getActiveBanners_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
2347 
    if result.success is not None:
2348 
      return result.success
2349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2350 
 
8579 kshitij.so 2351 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2352 
    """
2353 
    Parameters:
8579 kshitij.so 2354 
     - bannerMaps
6849 kshitij.so 2355 
    """
8579 kshitij.so 2356 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2357 
    return self.recv_addBannerMap()
2358 
 
8579 kshitij.so 2359 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2360 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2361 
    args = addBannerMap_args()
8579 kshitij.so 2362 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
2367 
  def recv_addBannerMap(self, ):
2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
2374 
    result = addBannerMap_result()
2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
2377 
    if result.success is not None:
2378 
      return result.success
2379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2380 
 
8579 kshitij.so 2381 
  def updateBannerMap(self, bannerMap):
2382 
    """
2383 
    Parameters:
2384 
     - bannerMap
2385 
    """
2386 
    self.send_updateBannerMap(bannerMap)
2387 
    return self.recv_updateBannerMap()
2388 
 
2389 
  def send_updateBannerMap(self, bannerMap):
2390 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2391 
    args = updateBannerMap_args()
2392 
    args.bannerMap = bannerMap
2393 
    args.write(self._oprot)
2394 
    self._oprot.writeMessageEnd()
2395 
    self._oprot.trans.flush()
2396 
 
2397 
  def recv_updateBannerMap(self, ):
2398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2399 
    if mtype == TMessageType.EXCEPTION:
2400 
      x = TApplicationException()
2401 
      x.read(self._iprot)
2402 
      self._iprot.readMessageEnd()
2403 
      raise x
2404 
    result = updateBannerMap_result()
2405 
    result.read(self._iprot)
2406 
    self._iprot.readMessageEnd()
2407 
    if result.success is not None:
2408 
      return result.success
2409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2410 
 
6849 kshitij.so 2411 
  def deleteBannerMap(self, bannerName):
2412 
    """
2413 
    Parameters:
2414 
     - bannerName
2415 
    """
2416 
    self.send_deleteBannerMap(bannerName)
2417 
    return self.recv_deleteBannerMap()
2418 
 
2419 
  def send_deleteBannerMap(self, bannerName):
2420 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2421 
    args = deleteBannerMap_args()
2422 
    args.bannerName = bannerName
2423 
    args.write(self._oprot)
2424 
    self._oprot.writeMessageEnd()
2425 
    self._oprot.trans.flush()
2426 
 
2427 
  def recv_deleteBannerMap(self, ):
2428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2429 
    if mtype == TMessageType.EXCEPTION:
2430 
      x = TApplicationException()
2431 
      x.read(self._iprot)
2432 
      self._iprot.readMessageEnd()
2433 
      raise x
2434 
    result = deleteBannerMap_result()
2435 
    result.read(self._iprot)
2436 
    self._iprot.readMessageEnd()
2437 
    if result.success is not None:
2438 
      return result.success
2439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2440 
 
2441 
  def getBannerMapDetails(self, bannerName):
2442 
    """
2443 
    Parameters:
2444 
     - bannerName
2445 
    """
2446 
    self.send_getBannerMapDetails(bannerName)
2447 
    return self.recv_getBannerMapDetails()
2448 
 
2449 
  def send_getBannerMapDetails(self, bannerName):
2450 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2451 
    args = getBannerMapDetails_args()
2452 
    args.bannerName = bannerName
2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
2457 
  def recv_getBannerMapDetails(self, ):
2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
2464 
    result = getBannerMapDetails_result()
2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
2467 
    if result.success is not None:
2468 
      return result.success
2469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2470 
 
8579 kshitij.so 2471 
  def addBannerUri(self, bannerUriMappings):
2472 
    """
2473 
    Parameters:
2474 
     - bannerUriMappings
2475 
    """
2476 
    self.send_addBannerUri(bannerUriMappings)
2477 
    self.recv_addBannerUri()
2478 
 
2479 
  def send_addBannerUri(self, bannerUriMappings):
2480 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2481 
    args = addBannerUri_args()
2482 
    args.bannerUriMappings = bannerUriMappings
2483 
    args.write(self._oprot)
2484 
    self._oprot.writeMessageEnd()
2485 
    self._oprot.trans.flush()
2486 
 
2487 
  def recv_addBannerUri(self, ):
2488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2489 
    if mtype == TMessageType.EXCEPTION:
2490 
      x = TApplicationException()
2491 
      x.read(self._iprot)
2492 
      self._iprot.readMessageEnd()
2493 
      raise x
2494 
    result = addBannerUri_result()
2495 
    result.read(self._iprot)
2496 
    self._iprot.readMessageEnd()
2497 
    return
2498 
 
2499 
  def getUriMapping(self, bannerName):
2500 
    """
2501 
    Parameters:
2502 
     - bannerName
2503 
    """
2504 
    self.send_getUriMapping(bannerName)
2505 
    return self.recv_getUriMapping()
2506 
 
2507 
  def send_getUriMapping(self, bannerName):
2508 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2509 
    args = getUriMapping_args()
2510 
    args.bannerName = bannerName
2511 
    args.write(self._oprot)
2512 
    self._oprot.writeMessageEnd()
2513 
    self._oprot.trans.flush()
2514 
 
2515 
  def recv_getUriMapping(self, ):
2516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2517 
    if mtype == TMessageType.EXCEPTION:
2518 
      x = TApplicationException()
2519 
      x.read(self._iprot)
2520 
      self._iprot.readMessageEnd()
2521 
      raise x
2522 
    result = getUriMapping_result()
2523 
    result.read(self._iprot)
2524 
    self._iprot.readMessageEnd()
2525 
    if result.success is not None:
2526 
      return result.success
2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2528 
 
2529 
  def addCampaign(self, campaign):
2530 
    """
2531 
    Parameters:
2532 
     - campaign
2533 
    """
2534 
    self.send_addCampaign(campaign)
2535 
    self.recv_addCampaign()
2536 
 
2537 
  def send_addCampaign(self, campaign):
2538 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2539 
    args = addCampaign_args()
2540 
    args.campaign = campaign
2541 
    args.write(self._oprot)
2542 
    self._oprot.writeMessageEnd()
2543 
    self._oprot.trans.flush()
2544 
 
2545 
  def recv_addCampaign(self, ):
2546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2547 
    if mtype == TMessageType.EXCEPTION:
2548 
      x = TApplicationException()
2549 
      x.read(self._iprot)
2550 
      self._iprot.readMessageEnd()
2551 
      raise x
2552 
    result = addCampaign_result()
2553 
    result.read(self._iprot)
2554 
    self._iprot.readMessageEnd()
2555 
    return
2556 
 
2557 
  def getCampaigns(self, campaignName):
2558 
    """
2559 
    Parameters:
2560 
     - campaignName
2561 
    """
2562 
    self.send_getCampaigns(campaignName)
2563 
    return self.recv_getCampaigns()
2564 
 
2565 
  def send_getCampaigns(self, campaignName):
2566 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2567 
    args = getCampaigns_args()
2568 
    args.campaignName = campaignName
2569 
    args.write(self._oprot)
2570 
    self._oprot.writeMessageEnd()
2571 
    self._oprot.trans.flush()
2572 
 
2573 
  def recv_getCampaigns(self, ):
2574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2575 
    if mtype == TMessageType.EXCEPTION:
2576 
      x = TApplicationException()
2577 
      x.read(self._iprot)
2578 
      self._iprot.readMessageEnd()
2579 
      raise x
2580 
    result = getCampaigns_result()
2581 
    result.read(self._iprot)
2582 
    self._iprot.readMessageEnd()
2583 
    if result.success is not None:
2584 
      return result.success
2585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2586 
 
2587 
  def deleteCampaign(self, campaignId):
2588 
    """
2589 
    Parameters:
2590 
     - campaignId
2591 
    """
2592 
    self.send_deleteCampaign(campaignId)
2593 
    self.recv_deleteCampaign()
2594 
 
2595 
  def send_deleteCampaign(self, campaignId):
2596 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2597 
    args = deleteCampaign_args()
2598 
    args.campaignId = campaignId
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_deleteCampaign(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = deleteCampaign_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    return
2614 
 
2615 
  def getAllCampaigns(self, ):
2616 
    self.send_getAllCampaigns()
2617 
    return self.recv_getAllCampaigns()
2618 
 
2619 
  def send_getAllCampaigns(self, ):
2620 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2621 
    args = getAllCampaigns_args()
2622 
    args.write(self._oprot)
2623 
    self._oprot.writeMessageEnd()
2624 
    self._oprot.trans.flush()
2625 
 
2626 
  def recv_getAllCampaigns(self, ):
2627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2628 
    if mtype == TMessageType.EXCEPTION:
2629 
      x = TApplicationException()
2630 
      x.read(self._iprot)
2631 
      self._iprot.readMessageEnd()
2632 
      raise x
2633 
    result = getAllCampaigns_result()
2634 
    result.read(self._iprot)
2635 
    self._iprot.readMessageEnd()
2636 
    if result.success is not None:
2637 
      return result.success
2638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2639 
 
5944 mandeep.dh 2640 
  def deleteSimilarItem(self, itemId, catalogItemId):
2641 
    """
2642 
    Delete similar item.
2643 
 
2644 
    Parameters:
2645 
     - itemId
2646 
     - catalogItemId
2647 
    """
2648 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2649 
    return self.recv_deleteSimilarItem()
2650 
 
2651 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2652 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2653 
    args = deleteSimilarItem_args()
2654 
    args.itemId = itemId
2655 
    args.catalogItemId = catalogItemId
2656 
    args.write(self._oprot)
2657 
    self._oprot.writeMessageEnd()
2658 
    self._oprot.trans.flush()
2659 
 
2660 
  def recv_deleteSimilarItem(self, ):
2661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2662 
    if mtype == TMessageType.EXCEPTION:
2663 
      x = TApplicationException()
2664 
      x.read(self._iprot)
2665 
      self._iprot.readMessageEnd()
2666 
      raise x
2667 
    result = deleteSimilarItem_result()
2668 
    result.read(self._iprot)
2669 
    self._iprot.readMessageEnd()
2670 
    if result.success is not None:
2671 
      return result.success
2672 
    if result.cex is not None:
2673 
      raise result.cex
2674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2675 
 
2676 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2677 
    """
2678 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2679 
    If yes, returns the itemId else returns 0
2680 
 
2681 
    Parameters:
2682 
     - brand
2683 
     - modelNumber
2684 
     - modelName
2685 
     - color
2686 
    """
2687 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2688 
    return self.recv_checkSimilarItem()
2689 
 
2690 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2691 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2692 
    args = checkSimilarItem_args()
2693 
    args.brand = brand
2694 
    args.modelNumber = modelNumber
2695 
    args.modelName = modelName
2696 
    args.color = color
2697 
    args.write(self._oprot)
2698 
    self._oprot.writeMessageEnd()
2699 
    self._oprot.trans.flush()
2700 
 
2701 
  def recv_checkSimilarItem(self, ):
2702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2703 
    if mtype == TMessageType.EXCEPTION:
2704 
      x = TApplicationException()
2705 
      x.read(self._iprot)
2706 
      self._iprot.readMessageEnd()
2707 
      raise x
2708 
    result = checkSimilarItem_result()
2709 
    result.read(self._iprot)
2710 
    self._iprot.readMessageEnd()
2711 
    if result.success is not None:
2712 
      return result.success
2713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2714 
 
2715 
  def validateRiskyStatus(self, itemId):
2716 
    """
2717 
    Check wether item is risky and change status if inventory is not available for risky items
2718 
 
2719 
    Parameters:
2720 
     - itemId
2721 
    """
2722 
    self.send_validateRiskyStatus(itemId)
2723 
    self.recv_validateRiskyStatus()
2724 
 
2725 
  def send_validateRiskyStatus(self, itemId):
2726 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2727 
    args = validateRiskyStatus_args()
2728 
    args.itemId = itemId
2729 
    args.write(self._oprot)
2730 
    self._oprot.writeMessageEnd()
2731 
    self._oprot.trans.flush()
2732 
 
2733 
  def recv_validateRiskyStatus(self, ):
2734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2735 
    if mtype == TMessageType.EXCEPTION:
2736 
      x = TApplicationException()
2737 
      x.read(self._iprot)
2738 
      self._iprot.readMessageEnd()
2739 
      raise x
2740 
    result = validateRiskyStatus_result()
2741 
    result.read(self._iprot)
2742 
    self._iprot.readMessageEnd()
2743 
    return
2744 
 
2745 
  def changeItemRiskyFlag(self, itemId, risky):
2746 
    """
2747 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2748 
 
2749 
    Parameters:
2750 
     - itemId
2751 
     - risky
2752 
    """
2753 
    self.send_changeItemRiskyFlag(itemId, risky)
2754 
    self.recv_changeItemRiskyFlag()
2755 
 
2756 
  def send_changeItemRiskyFlag(self, itemId, risky):
2757 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2758 
    args = changeItemRiskyFlag_args()
2759 
    args.itemId = itemId
2760 
    args.risky = risky
2761 
    args.write(self._oprot)
2762 
    self._oprot.writeMessageEnd()
2763 
    self._oprot.trans.flush()
2764 
 
2765 
  def recv_changeItemRiskyFlag(self, ):
2766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2767 
    if mtype == TMessageType.EXCEPTION:
2768 
      x = TApplicationException()
2769 
      x.read(self._iprot)
2770 
      self._iprot.readMessageEnd()
2771 
      raise x
2772 
    result = changeItemRiskyFlag_result()
2773 
    result.read(self._iprot)
2774 
    self._iprot.readMessageEnd()
2775 
    return
2776 
 
2777 
  def getItemsByRiskyFlag(self, ):
2778 
    """
2779 
    Returns list of items marked as risky.
2780 
    """
2781 
    self.send_getItemsByRiskyFlag()
2782 
    return self.recv_getItemsByRiskyFlag()
2783 
 
2784 
  def send_getItemsByRiskyFlag(self, ):
2785 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2786 
    args = getItemsByRiskyFlag_args()
2787 
    args.write(self._oprot)
2788 
    self._oprot.writeMessageEnd()
2789 
    self._oprot.trans.flush()
2790 
 
2791 
  def recv_getItemsByRiskyFlag(self, ):
2792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2793 
    if mtype == TMessageType.EXCEPTION:
2794 
      x = TApplicationException()
2795 
      x.read(self._iprot)
2796 
      self._iprot.readMessageEnd()
2797 
      raise x
2798 
    result = getItemsByRiskyFlag_result()
2799 
    result.read(self._iprot)
2800 
    self._iprot.readMessageEnd()
2801 
    if result.success is not None:
2802 
      return result.success
2803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2804 
 
2805 
  def getItemsForMasterSheet(self, category, brand):
2806 
    """
2807 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2808 
 
2809 
    Parameters:
2810 
     - category
2811 
     - brand
2812 
    """
2813 
    self.send_getItemsForMasterSheet(category, brand)
2814 
    return self.recv_getItemsForMasterSheet()
2815 
 
2816 
  def send_getItemsForMasterSheet(self, category, brand):
2817 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2818 
    args = getItemsForMasterSheet_args()
2819 
    args.category = category
2820 
    args.brand = brand
2821 
    args.write(self._oprot)
2822 
    self._oprot.writeMessageEnd()
2823 
    self._oprot.trans.flush()
2824 
 
2825 
  def recv_getItemsForMasterSheet(self, ):
2826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2827 
    if mtype == TMessageType.EXCEPTION:
2828 
      x = TApplicationException()
2829 
      x.read(self._iprot)
2830 
      self._iprot.readMessageEnd()
2831 
      raise x
2832 
    result = getItemsForMasterSheet_result()
2833 
    result.read(self._iprot)
2834 
    self._iprot.readMessageEnd()
2835 
    if result.success is not None:
2836 
      return result.success
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2838 
 
2839 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2840 
    """
2841 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2842 
 
2843 
    Parameters:
2844 
     - beginIndex
2845 
     - totalItems
2846 
     - itemId
2847 
    """
2848 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2849 
    return self.recv_getSimilarItemsCatalogIds()
2850 
 
2851 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2852 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2853 
    args = getSimilarItemsCatalogIds_args()
2854 
    args.beginIndex = beginIndex
2855 
    args.totalItems = totalItems
2856 
    args.itemId = itemId
2857 
    args.write(self._oprot)
2858 
    self._oprot.writeMessageEnd()
2859 
    self._oprot.trans.flush()
2860 
 
2861 
  def recv_getSimilarItemsCatalogIds(self, ):
2862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2863 
    if mtype == TMessageType.EXCEPTION:
2864 
      x = TApplicationException()
2865 
      x.read(self._iprot)
2866 
      self._iprot.readMessageEnd()
2867 
      raise x
2868 
    result = getSimilarItemsCatalogIds_result()
2869 
    result.read(self._iprot)
2870 
    self._iprot.readMessageEnd()
2871 
    if result.success is not None:
2872 
      return result.success
2873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2874 
 
2875 
  def addProductNotification(self, itemId, email):
2876 
    """
2877 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2878 
 
2879 
    Parameters:
2880 
     - itemId
2881 
     - email
2882 
    """
2883 
    self.send_addProductNotification(itemId, email)
2884 
    return self.recv_addProductNotification()
2885 
 
2886 
  def send_addProductNotification(self, itemId, email):
2887 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2888 
    args = addProductNotification_args()
2889 
    args.itemId = itemId
2890 
    args.email = email
2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2895 
  def recv_addProductNotification(self, ):
2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2902 
    result = addProductNotification_result()
2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.success is not None:
2906 
      return result.success
2907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2908 
 
2909 
  def sendProductNotifications(self, ):
2910 
    """
2911 
    Send the product notifications to the users for items which has stock.
2912 
    """
2913 
    self.send_sendProductNotifications()
2914 
    return self.recv_sendProductNotifications()
2915 
 
2916 
  def send_sendProductNotifications(self, ):
2917 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2918 
    args = sendProductNotifications_args()
2919 
    args.write(self._oprot)
2920 
    self._oprot.writeMessageEnd()
2921 
    self._oprot.trans.flush()
2922 
 
2923 
  def recv_sendProductNotifications(self, ):
2924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2925 
    if mtype == TMessageType.EXCEPTION:
2926 
      x = TApplicationException()
2927 
      x.read(self._iprot)
2928 
      self._iprot.readMessageEnd()
2929 
      raise x
2930 
    result = sendProductNotifications_result()
2931 
    result.read(self._iprot)
2932 
    self._iprot.readMessageEnd()
2933 
    if result.success is not None:
2934 
      return result.success
2935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2936 
 
2937 
  def getAllBrandsByCategory(self, categoryId):
2938 
    """
2939 
    Returns list of brand names for a given category Id
2940 
 
2941 
    Parameters:
2942 
     - categoryId
2943 
    """
2944 
    self.send_getAllBrandsByCategory(categoryId)
2945 
    return self.recv_getAllBrandsByCategory()
2946 
 
2947 
  def send_getAllBrandsByCategory(self, categoryId):
2948 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2949 
    args = getAllBrandsByCategory_args()
2950 
    args.categoryId = categoryId
2951 
    args.write(self._oprot)
2952 
    self._oprot.writeMessageEnd()
2953 
    self._oprot.trans.flush()
2954 
 
2955 
  def recv_getAllBrandsByCategory(self, ):
2956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2957 
    if mtype == TMessageType.EXCEPTION:
2958 
      x = TApplicationException()
2959 
      x.read(self._iprot)
2960 
      self._iprot.readMessageEnd()
2961 
      raise x
2962 
    result = getAllBrandsByCategory_result()
2963 
    result.read(self._iprot)
2964 
    self._iprot.readMessageEnd()
2965 
    if result.success is not None:
2966 
      return result.success
2967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2968 
 
2969 
  def getAllBrands(self, ):
2970 
    """
2971 
    Returns list of brand names
2972 
    """
2973 
    self.send_getAllBrands()
2974 
    return self.recv_getAllBrands()
2975 
 
2976 
  def send_getAllBrands(self, ):
2977 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2978 
    args = getAllBrands_args()
2979 
    args.write(self._oprot)
2980 
    self._oprot.writeMessageEnd()
2981 
    self._oprot.trans.flush()
2982 
 
2983 
  def recv_getAllBrands(self, ):
2984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2985 
    if mtype == TMessageType.EXCEPTION:
2986 
      x = TApplicationException()
2987 
      x.read(self._iprot)
2988 
      self._iprot.readMessageEnd()
2989 
      raise x
2990 
    result = getAllBrands_result()
2991 
    result.read(self._iprot)
2992 
    self._iprot.readMessageEnd()
2993 
    if result.success is not None:
2994 
      return result.success
2995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2996 
 
2997 
  def getAllSources(self, ):
2998 
    """
2999 
    Return list of all sources
3000 
    """
3001 
    self.send_getAllSources()
3002 
    return self.recv_getAllSources()
3003 
 
3004 
  def send_getAllSources(self, ):
3005 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3006 
    args = getAllSources_args()
3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_getAllSources(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = getAllSources_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.success is not None:
3022 
      return result.success
3023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3024 
 
3025 
  def getItemPricingBySource(self, itemId, sourceId):
3026 
    """
3027 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3028 
 
3029 
    Parameters:
3030 
     - itemId
3031 
     - sourceId
3032 
    """
3033 
    self.send_getItemPricingBySource(itemId, sourceId)
3034 
    return self.recv_getItemPricingBySource()
3035 
 
3036 
  def send_getItemPricingBySource(self, itemId, sourceId):
3037 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3038 
    args = getItemPricingBySource_args()
3039 
    args.itemId = itemId
3040 
    args.sourceId = sourceId
3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
3045 
  def recv_getItemPricingBySource(self, ):
3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
3052 
    result = getItemPricingBySource_result()
3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3055 
    if result.success is not None:
3056 
      return result.success
3057 
    if result.cex is not None:
3058 
      raise result.cex
3059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3060 
 
3061 
  def addSourceItemPricing(self, sourceItemPricing):
3062 
    """
3063 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3064 
    If item is not found or source is not found, it will throw exception.
3065 
 
3066 
    Parameters:
3067 
     - sourceItemPricing
3068 
    """
3069 
    self.send_addSourceItemPricing(sourceItemPricing)
3070 
    self.recv_addSourceItemPricing()
3071 
 
3072 
  def send_addSourceItemPricing(self, sourceItemPricing):
3073 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3074 
    args = addSourceItemPricing_args()
3075 
    args.sourceItemPricing = sourceItemPricing
3076 
    args.write(self._oprot)
3077 
    self._oprot.writeMessageEnd()
3078 
    self._oprot.trans.flush()
3079 
 
3080 
  def recv_addSourceItemPricing(self, ):
3081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3082 
    if mtype == TMessageType.EXCEPTION:
3083 
      x = TApplicationException()
3084 
      x.read(self._iprot)
3085 
      self._iprot.readMessageEnd()
3086 
      raise x
3087 
    result = addSourceItemPricing_result()
3088 
    result.read(self._iprot)
3089 
    self._iprot.readMessageEnd()
3090 
    if result.cex is not None:
3091 
      raise result.cex
3092 
    return
3093 
 
3094 
  def getAllSourcePricing(self, itemId):
3095 
    """
3096 
    Returns the list of source pricing information of an item.
3097 
    Raises an exception if item not found corresponding to itemId
3098 
 
3099 
    Parameters:
3100 
     - itemId
3101 
    """
3102 
    self.send_getAllSourcePricing(itemId)
3103 
    return self.recv_getAllSourcePricing()
3104 
 
3105 
  def send_getAllSourcePricing(self, itemId):
3106 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3107 
    args = getAllSourcePricing_args()
3108 
    args.itemId = itemId
3109 
    args.write(self._oprot)
3110 
    self._oprot.writeMessageEnd()
3111 
    self._oprot.trans.flush()
3112 
 
3113 
  def recv_getAllSourcePricing(self, ):
3114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3115 
    if mtype == TMessageType.EXCEPTION:
3116 
      x = TApplicationException()
3117 
      x.read(self._iprot)
3118 
      self._iprot.readMessageEnd()
3119 
      raise x
3120 
    result = getAllSourcePricing_result()
3121 
    result.read(self._iprot)
3122 
    self._iprot.readMessageEnd()
3123 
    if result.success is not None:
3124 
      return result.success
3125 
    if result.cex is not None:
3126 
      raise result.cex
3127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3128 
 
3129 
  def getItemForSource(self, item_id, sourceId):
3130 
    """
3131 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3132 
 
3133 
    Parameters:
3134 
     - item_id
3135 
     - sourceId
3136 
    """
3137 
    self.send_getItemForSource(item_id, sourceId)
3138 
    return self.recv_getItemForSource()
3139 
 
3140 
  def send_getItemForSource(self, item_id, sourceId):
3141 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3142 
    args = getItemForSource_args()
3143 
    args.item_id = item_id
3144 
    args.sourceId = sourceId
3145 
    args.write(self._oprot)
3146 
    self._oprot.writeMessageEnd()
3147 
    self._oprot.trans.flush()
3148 
 
3149 
  def recv_getItemForSource(self, ):
3150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3151 
    if mtype == TMessageType.EXCEPTION:
3152 
      x = TApplicationException()
3153 
      x.read(self._iprot)
3154 
      self._iprot.readMessageEnd()
3155 
      raise x
3156 
    result = getItemForSource_result()
3157 
    result.read(self._iprot)
3158 
    self._iprot.readMessageEnd()
3159 
    if result.success is not None:
3160 
      return result.success
3161 
    if result.cex is not None:
3162 
      raise result.cex
3163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3164 
 
3165 
  def searchItemsInRange(self, searchTerms, offset, limit):
3166 
    """
3167 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3168 
 
3169 
    Parameters:
3170 
     - searchTerms
3171 
     - offset
3172 
     - limit
3173 
    """
3174 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3175 
    return self.recv_searchItemsInRange()
3176 
 
3177 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3178 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3179 
    args = searchItemsInRange_args()
3180 
    args.searchTerms = searchTerms
3181 
    args.offset = offset
3182 
    args.limit = limit
3183 
    args.write(self._oprot)
3184 
    self._oprot.writeMessageEnd()
3185 
    self._oprot.trans.flush()
3186 
 
3187 
  def recv_searchItemsInRange(self, ):
3188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3189 
    if mtype == TMessageType.EXCEPTION:
3190 
      x = TApplicationException()
3191 
      x.read(self._iprot)
3192 
      self._iprot.readMessageEnd()
3193 
      raise x
3194 
    result = searchItemsInRange_result()
3195 
    result.read(self._iprot)
3196 
    self._iprot.readMessageEnd()
3197 
    if result.success is not None:
3198 
      return result.success
3199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3200 
 
3201 
  def getSearchResultCount(self, searchTerms):
3202 
    """
3203 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3204 
 
3205 
    Parameters:
3206 
     - searchTerms
3207 
    """
3208 
    self.send_getSearchResultCount(searchTerms)
3209 
    return self.recv_getSearchResultCount()
3210 
 
3211 
  def send_getSearchResultCount(self, searchTerms):
3212 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3213 
    args = getSearchResultCount_args()
3214 
    args.searchTerms = searchTerms
3215 
    args.write(self._oprot)
3216 
    self._oprot.writeMessageEnd()
3217 
    self._oprot.trans.flush()
3218 
 
3219 
  def recv_getSearchResultCount(self, ):
3220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3221 
    if mtype == TMessageType.EXCEPTION:
3222 
      x = TApplicationException()
3223 
      x.read(self._iprot)
3224 
      self._iprot.readMessageEnd()
3225 
      raise x
3226 
    result = getSearchResultCount_result()
3227 
    result.read(self._iprot)
3228 
    self._iprot.readMessageEnd()
3229 
    if result.success is not None:
3230 
      return result.success
3231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3232 
 
3233 
  def getProductNotifications(self, startDateTime):
3234 
    """
3235 
    Returns a list of product notifications added after a supplied datetime
3236 
 
3237 
    Parameters:
3238 
     - startDateTime
3239 
    """
3240 
    self.send_getProductNotifications(startDateTime)
3241 
    return self.recv_getProductNotifications()
3242 
 
3243 
  def send_getProductNotifications(self, startDateTime):
3244 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3245 
    args = getProductNotifications_args()
3246 
    args.startDateTime = startDateTime
3247 
    args.write(self._oprot)
3248 
    self._oprot.writeMessageEnd()
3249 
    self._oprot.trans.flush()
3250 
 
3251 
  def recv_getProductNotifications(self, ):
3252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3253 
    if mtype == TMessageType.EXCEPTION:
3254 
      x = TApplicationException()
3255 
      x.read(self._iprot)
3256 
      self._iprot.readMessageEnd()
3257 
      raise x
3258 
    result = getProductNotifications_result()
3259 
    result.read(self._iprot)
3260 
    self._iprot.readMessageEnd()
3261 
    if result.success is not None:
3262 
      return result.success
3263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3264 
 
7897 amar.kumar 3265 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3266 
    """
3267 
    Returns a list of count of requests for product notification against each item
3268 
 
3269 
    Parameters:
3270 
     - startDateTime
7897 amar.kumar 3271 
     - categoryId
5944 mandeep.dh 3272 
    """
7897 amar.kumar 3273 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3274 
    return self.recv_getProductNotificationRequestCount()
3275 
 
7897 amar.kumar 3276 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3277 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3278 
    args = getProductNotificationRequestCount_args()
3279 
    args.startDateTime = startDateTime
7897 amar.kumar 3280 
    args.categoryId = categoryId
5944 mandeep.dh 3281 
    args.write(self._oprot)
3282 
    self._oprot.writeMessageEnd()
3283 
    self._oprot.trans.flush()
3284 
 
3285 
  def recv_getProductNotificationRequestCount(self, ):
3286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3287 
    if mtype == TMessageType.EXCEPTION:
3288 
      x = TApplicationException()
3289 
      x.read(self._iprot)
3290 
      self._iprot.readMessageEnd()
3291 
      raise x
3292 
    result = getProductNotificationRequestCount_result()
3293 
    result.read(self._iprot)
3294 
    self._iprot.readMessageEnd()
3295 
    if result.success is not None:
3296 
      return result.success
3297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3298 
 
3299 
  def addAuthorizationLog(self, itemId, username, reason):
3300 
    """
3301 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3302 
 
3303 
    Parameters:
3304 
     - itemId
3305 
     - username
3306 
     - reason
3307 
    """
3308 
    self.send_addAuthorizationLog(itemId, username, reason)
3309 
    return self.recv_addAuthorizationLog()
3310 
 
3311 
  def send_addAuthorizationLog(self, itemId, username, reason):
3312 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3313 
    args = addAuthorizationLog_args()
3314 
    args.itemId = itemId
3315 
    args.username = username
3316 
    args.reason = reason
3317 
    args.write(self._oprot)
3318 
    self._oprot.writeMessageEnd()
3319 
    self._oprot.trans.flush()
3320 
 
3321 
  def recv_addAuthorizationLog(self, ):
3322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3323 
    if mtype == TMessageType.EXCEPTION:
3324 
      x = TApplicationException()
3325 
      x.read(self._iprot)
3326 
      self._iprot.readMessageEnd()
3327 
      raise x
3328 
    result = addAuthorizationLog_result()
3329 
    result.read(self._iprot)
3330 
    self._iprot.readMessageEnd()
3331 
    if result.success is not None:
3332 
      return result.success
3333 
    if result.cex is not None:
3334 
      raise result.cex
3335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3336 
 
3337 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3338 
    """
3339 
    Parameters:
3340 
     - catalog_item_id
3341 
     - voucherType
3342 
     - voucherAmount
3343 
    """
3344 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3345 
    return self.recv_addupdateVoucherForItem()
3346 
 
3347 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3348 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3349 
    args = addupdateVoucherForItem_args()
3350 
    args.catalog_item_id = catalog_item_id
3351 
    args.voucherType = voucherType
3352 
    args.voucherAmount = voucherAmount
3353 
    args.write(self._oprot)
3354 
    self._oprot.writeMessageEnd()
3355 
    self._oprot.trans.flush()
3356 
 
3357 
  def recv_addupdateVoucherForItem(self, ):
3358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3359 
    if mtype == TMessageType.EXCEPTION:
3360 
      x = TApplicationException()
3361 
      x.read(self._iprot)
3362 
      self._iprot.readMessageEnd()
3363 
      raise x
3364 
    result = addupdateVoucherForItem_result()
3365 
    result.read(self._iprot)
3366 
    self._iprot.readMessageEnd()
3367 
    if result.success is not None:
3368 
      return result.success
3369 
    if result.cex is not None:
3370 
      raise result.cex
3371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3372 
 
3373 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3374 
    """
3375 
    Parameters:
3376 
     - catalog_item_id
3377 
     - voucherType
3378 
    """
3379 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3380 
    return self.recv_deleteVoucherForItem()
3381 
 
3382 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3383 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3384 
    args = deleteVoucherForItem_args()
3385 
    args.catalog_item_id = catalog_item_id
3386 
    args.voucherType = voucherType
3387 
    args.write(self._oprot)
3388 
    self._oprot.writeMessageEnd()
3389 
    self._oprot.trans.flush()
3390 
 
3391 
  def recv_deleteVoucherForItem(self, ):
3392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3393 
    if mtype == TMessageType.EXCEPTION:
3394 
      x = TApplicationException()
3395 
      x.read(self._iprot)
3396 
      self._iprot.readMessageEnd()
3397 
      raise x
3398 
    result = deleteVoucherForItem_result()
3399 
    result.read(self._iprot)
3400 
    self._iprot.readMessageEnd()
3401 
    if result.success is not None:
3402 
      return result.success
3403 
    if result.cex is not None:
3404 
      raise result.cex
3405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3406 
 
3407 
  def getVoucherAmount(self, itemId, voucherType):
3408 
    """
3409 
    Parameters:
3410 
     - itemId
3411 
     - voucherType
3412 
    """
3413 
    self.send_getVoucherAmount(itemId, voucherType)
3414 
    return self.recv_getVoucherAmount()
3415 
 
3416 
  def send_getVoucherAmount(self, itemId, voucherType):
3417 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3418 
    args = getVoucherAmount_args()
3419 
    args.itemId = itemId
3420 
    args.voucherType = voucherType
3421 
    args.write(self._oprot)
3422 
    self._oprot.writeMessageEnd()
3423 
    self._oprot.trans.flush()
3424 
 
3425 
  def recv_getVoucherAmount(self, ):
3426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3427 
    if mtype == TMessageType.EXCEPTION:
3428 
      x = TApplicationException()
3429 
      x.read(self._iprot)
3430 
      self._iprot.readMessageEnd()
3431 
      raise x
3432 
    result = getVoucherAmount_result()
3433 
    result.read(self._iprot)
3434 
    self._iprot.readMessageEnd()
3435 
    if result.success is not None:
3436 
      return result.success
3437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3438 
 
3439 
  def getAllItemVouchers(self, itemId):
3440 
    """
3441 
    Parameters:
3442 
     - itemId
3443 
    """
3444 
    self.send_getAllItemVouchers(itemId)
3445 
    return self.recv_getAllItemVouchers()
3446 
 
3447 
  def send_getAllItemVouchers(self, itemId):
3448 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3449 
    args = getAllItemVouchers_args()
3450 
    args.itemId = itemId
3451 
    args.write(self._oprot)
3452 
    self._oprot.writeMessageEnd()
3453 
    self._oprot.trans.flush()
3454 
 
3455 
  def recv_getAllItemVouchers(self, ):
3456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3457 
    if mtype == TMessageType.EXCEPTION:
3458 
      x = TApplicationException()
3459 
      x.read(self._iprot)
3460 
      self._iprot.readMessageEnd()
3461 
      raise x
3462 
    result = getAllItemVouchers_result()
3463 
    result.read(self._iprot)
3464 
    self._iprot.readMessageEnd()
3465 
    if result.success is not None:
3466 
      return result.success
3467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3468 
 
3469 
  def isValidCatalogItemId(self, catalog_item_id):
3470 
    """
3471 
    Parameters:
3472 
     - catalog_item_id
3473 
    """
3474 
    self.send_isValidCatalogItemId(catalog_item_id)
3475 
    return self.recv_isValidCatalogItemId()
3476 
 
3477 
  def send_isValidCatalogItemId(self, catalog_item_id):
3478 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3479 
    args = isValidCatalogItemId_args()
3480 
    args.catalog_item_id = catalog_item_id
3481 
    args.write(self._oprot)
3482 
    self._oprot.writeMessageEnd()
3483 
    self._oprot.trans.flush()
3484 
 
3485 
  def recv_isValidCatalogItemId(self, ):
3486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3487 
    if mtype == TMessageType.EXCEPTION:
3488 
      x = TApplicationException()
3489 
      x.read(self._iprot)
3490 
      self._iprot.readMessageEnd()
3491 
      raise x
3492 
    result = isValidCatalogItemId_result()
3493 
    result.read(self._iprot)
3494 
    self._iprot.readMessageEnd()
3495 
    if result.success is not None:
3496 
      return result.success
3497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3498 
 
7330 amit.gupta 3499 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3500 
    """
3501 
    Parameters:
3502 
     - itemId
7330 amit.gupta 3503 
     - stateId
6039 amit.gupta 3504 
     - price
3505 
    """
7330 amit.gupta 3506 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3507 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3508 
 
7330 amit.gupta 3509 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3510 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3511 
    args = getVatPercentageForItem_args()
3512 
    args.itemId = itemId
7330 amit.gupta 3513 
    args.stateId = stateId
6039 amit.gupta 3514 
    args.price = price
3515 
    args.write(self._oprot)
3516 
    self._oprot.writeMessageEnd()
3517 
    self._oprot.trans.flush()
3518 
 
3519 
  def recv_getVatPercentageForItem(self, ):
3520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3521 
    if mtype == TMessageType.EXCEPTION:
3522 
      x = TApplicationException()
3523 
      x.read(self._iprot)
3524 
      self._iprot.readMessageEnd()
3525 
      raise x
3526 
    result = getVatPercentageForItem_result()
3527 
    result.read(self._iprot)
3528 
    self._iprot.readMessageEnd()
3529 
    if result.success is not None:
3530 
      return result.success
7340 amit.gupta 3531 
    if result.cex is not None:
3532 
      raise result.cex
6039 amit.gupta 3533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3534 
 
3535 
  def getVatAmountForItem(self, itemId, price):
3536 
    """
3537 
    Parameters:
3538 
     - itemId
3539 
     - price
3540 
    """
3541 
    self.send_getVatAmountForItem(itemId, price)
3542 
    return self.recv_getVatAmountForItem()
3543 
 
3544 
  def send_getVatAmountForItem(self, itemId, price):
3545 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3546 
    args = getVatAmountForItem_args()
3547 
    args.itemId = itemId
3548 
    args.price = price
3549 
    args.write(self._oprot)
3550 
    self._oprot.writeMessageEnd()
3551 
    self._oprot.trans.flush()
3552 
 
3553 
  def recv_getVatAmountForItem(self, ):
3554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3555 
    if mtype == TMessageType.EXCEPTION:
3556 
      x = TApplicationException()
3557 
      x.read(self._iprot)
3558 
      self._iprot.readMessageEnd()
3559 
      raise x
3560 
    result = getVatAmountForItem_result()
3561 
    result.read(self._iprot)
3562 
    self._iprot.readMessageEnd()
3563 
    if result.success is not None:
3564 
      return result.success
3565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3566 
 
6531 vikram.rag 3567 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3568 
    """
3569 
    Parameters:
3570 
     - offset
3571 
     - limit
3572 
    """
3573 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3574 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3575 
 
6531 vikram.rag 3576 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3577 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3578 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3579 
    args.offset = offset
3580 
    args.limit = limit
3581 
    args.write(self._oprot)
3582 
    self._oprot.writeMessageEnd()
3583 
    self._oprot.trans.flush()
3584 
 
3585 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3587 
    if mtype == TMessageType.EXCEPTION:
3588 
      x = TApplicationException()
3589 
      x.read(self._iprot)
3590 
      self._iprot.readMessageEnd()
3591 
      raise x
3592 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3593 
    result.read(self._iprot)
3594 
    self._iprot.readMessageEnd()
3595 
    if result.success is not None:
3596 
      return result.success
3597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3598 
 
6821 amar.kumar 3599 
  def getAllAliveItems(self, ):
3600 
    self.send_getAllAliveItems()
3601 
    return self.recv_getAllAliveItems()
3602 
 
3603 
  def send_getAllAliveItems(self, ):
3604 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3605 
    args = getAllAliveItems_args()
3606 
    args.write(self._oprot)
3607 
    self._oprot.writeMessageEnd()
3608 
    self._oprot.trans.flush()
3609 
 
3610 
  def recv_getAllAliveItems(self, ):
3611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3612 
    if mtype == TMessageType.EXCEPTION:
3613 
      x = TApplicationException()
3614 
      x.read(self._iprot)
3615 
      self._iprot.readMessageEnd()
3616 
      raise x
3617 
    result = getAllAliveItems_result()
3618 
    result.read(self._iprot)
3619 
    self._iprot.readMessageEnd()
3620 
    if result.success is not None:
3621 
      return result.success
3622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3623 
 
6921 anupam.sin 3624 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3625 
    """
3626 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3627 
 
6805 anupam.sin 3628 
    Parameters:
3629 
     - itemId
6921 anupam.sin 3630 
     - price
6805 anupam.sin 3631 
     - insurerId
3632 
     - quantity
3633 
    """
6921 anupam.sin 3634 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3635 
    return self.recv_getInsuranceAmount()
3636 
 
6921 anupam.sin 3637 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3638 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3639 
    args = getInsuranceAmount_args()
3640 
    args.itemId = itemId
6921 anupam.sin 3641 
    args.price = price
6805 anupam.sin 3642 
    args.insurerId = insurerId
3643 
    args.quantity = quantity
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_getInsuranceAmount(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = getInsuranceAmount_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
3658 
    if result.success is not None:
3659 
      return result.success
3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3661 
 
3662 
  def getInsurer(self, insurerId):
3663 
    """
3664 
    Parameters:
3665 
     - insurerId
3666 
    """
3667 
    self.send_getInsurer(insurerId)
3668 
    return self.recv_getInsurer()
3669 
 
3670 
  def send_getInsurer(self, insurerId):
3671 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3672 
    args = getInsurer_args()
3673 
    args.insurerId = insurerId
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_getInsurer(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = getInsurer_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3688 
    if result.success is not None:
3689 
      return result.success
3690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3691 
 
6838 vikram.rag 3692 
  def getAllInsurers(self, ):
3693 
    self.send_getAllInsurers()
3694 
    return self.recv_getAllInsurers()
6805 anupam.sin 3695 
 
6838 vikram.rag 3696 
  def send_getAllInsurers(self, ):
3697 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3698 
    args = getAllInsurers_args()
3699 
    args.write(self._oprot)
3700 
    self._oprot.writeMessageEnd()
3701 
    self._oprot.trans.flush()
3702 
 
3703 
  def recv_getAllInsurers(self, ):
3704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3705 
    if mtype == TMessageType.EXCEPTION:
3706 
      x = TApplicationException()
3707 
      x.read(self._iprot)
3708 
      self._iprot.readMessageEnd()
3709 
      raise x
3710 
    result = getAllInsurers_result()
3711 
    result.read(self._iprot)
3712 
    self._iprot.readMessageEnd()
3713 
    if result.success is not None:
3714 
      return result.success
3715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3716 
 
6962 rajveer 3717 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3718 
    """
3719 
    Parameters:
3720 
     - insurerId
3721 
     - amount
3722 
    """
3723 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3724 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3725 
 
6962 rajveer 3726 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3727 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3728 
    args = updateInsuranceDeclaredAmount_args()
3729 
    args.insurerId = insurerId
3730 
    args.amount = amount
3731 
    args.write(self._oprot)
3732 
    self._oprot.writeMessageEnd()
3733 
    self._oprot.trans.flush()
3734 
 
3735 
  def recv_updateInsuranceDeclaredAmount(self, ):
3736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3737 
    if mtype == TMessageType.EXCEPTION:
3738 
      x = TApplicationException()
3739 
      x.read(self._iprot)
3740 
      self._iprot.readMessageEnd()
3741 
      raise x
3742 
    result = updateInsuranceDeclaredAmount_result()
3743 
    result.read(self._iprot)
3744 
    self._iprot.readMessageEnd()
3745 
    return
3746 
 
7190 amar.kumar 3747 
  def getFreebieForItem(self, itemId):
3748 
    """
3749 
    Parameters:
3750 
     - itemId
3751 
    """
3752 
    self.send_getFreebieForItem(itemId)
3753 
    return self.recv_getFreebieForItem()
6962 rajveer 3754 
 
7190 amar.kumar 3755 
  def send_getFreebieForItem(self, itemId):
3756 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3757 
    args = getFreebieForItem_args()
3758 
    args.itemId = itemId
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_getFreebieForItem(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = getFreebieForItem_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3776 
 
3777 
  def addOrUpdateFreebieForItem(self, freebieItem):
3778 
    """
3779 
    Parameters:
3780 
     - freebieItem
3781 
    """
3782 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3783 
    self.recv_addOrUpdateFreebieForItem()
3784 
 
3785 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3786 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3787 
    args = addOrUpdateFreebieForItem_args()
3788 
    args.freebieItem = freebieItem
3789 
    args.write(self._oprot)
3790 
    self._oprot.writeMessageEnd()
3791 
    self._oprot.trans.flush()
3792 
 
3793 
  def recv_addOrUpdateFreebieForItem(self, ):
3794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3795 
    if mtype == TMessageType.EXCEPTION:
3796 
      x = TApplicationException()
3797 
      x.read(self._iprot)
3798 
      self._iprot.readMessageEnd()
3799 
      raise x
3800 
    result = addOrUpdateFreebieForItem_result()
3801 
    result.read(self._iprot)
3802 
    self._iprot.readMessageEnd()
3803 
    return
3804 
 
7272 amit.gupta 3805 
  def addOrUpdateBrandInfo(self, brandInfo):
3806 
    """
3807 
    Parameters:
3808 
     - brandInfo
3809 
    """
3810 
    self.send_addOrUpdateBrandInfo(brandInfo)
3811 
    self.recv_addOrUpdateBrandInfo()
3812 
 
3813 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3814 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3815 
    args = addOrUpdateBrandInfo_args()
3816 
    args.brandInfo = brandInfo
3817 
    args.write(self._oprot)
3818 
    self._oprot.writeMessageEnd()
3819 
    self._oprot.trans.flush()
3820 
 
3821 
  def recv_addOrUpdateBrandInfo(self, ):
3822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3823 
    if mtype == TMessageType.EXCEPTION:
3824 
      x = TApplicationException()
3825 
      x.read(self._iprot)
3826 
      self._iprot.readMessageEnd()
3827 
      raise x
3828 
    result = addOrUpdateBrandInfo_result()
3829 
    result.read(self._iprot)
3830 
    self._iprot.readMessageEnd()
3831 
    return
3832 
 
3833 
  def getBrandInfo(self, ):
3834 
    self.send_getBrandInfo()
3835 
    return self.recv_getBrandInfo()
3836 
 
3837 
  def send_getBrandInfo(self, ):
3838 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3839 
    args = getBrandInfo_args()
3840 
    args.write(self._oprot)
3841 
    self._oprot.writeMessageEnd()
3842 
    self._oprot.trans.flush()
3843 
 
3844 
  def recv_getBrandInfo(self, ):
3845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3846 
    if mtype == TMessageType.EXCEPTION:
3847 
      x = TApplicationException()
3848 
      x.read(self._iprot)
3849 
      self._iprot.readMessageEnd()
3850 
      raise x
3851 
    result = getBrandInfo_result()
3852 
    result.read(self._iprot)
3853 
    self._iprot.readMessageEnd()
3854 
    if result.success is not None:
3855 
      return result.success
3856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3857 
 
7256 rajveer 3858 
  def getStorePricing(self, itemId):
3859 
    """
3860 
    Parameters:
3861 
     - itemId
3862 
    """
3863 
    self.send_getStorePricing(itemId)
3864 
    return self.recv_getStorePricing()
7190 amar.kumar 3865 
 
7256 rajveer 3866 
  def send_getStorePricing(self, itemId):
3867 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3868 
    args = getStorePricing_args()
3869 
    args.itemId = itemId
3870 
    args.write(self._oprot)
3871 
    self._oprot.writeMessageEnd()
3872 
    self._oprot.trans.flush()
3873 
 
3874 
  def recv_getStorePricing(self, ):
3875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3876 
    if mtype == TMessageType.EXCEPTION:
3877 
      x = TApplicationException()
3878 
      x.read(self._iprot)
3879 
      self._iprot.readMessageEnd()
3880 
      raise x
3881 
    result = getStorePricing_result()
3882 
    result.read(self._iprot)
3883 
    self._iprot.readMessageEnd()
3884 
    if result.success is not None:
3885 
      return result.success
3886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3887 
 
7306 rajveer 3888 
  def getStorePricings(self, itemIds):
3889 
    """
3890 
    Parameters:
3891 
     - itemIds
3892 
    """
3893 
    self.send_getStorePricings(itemIds)
3894 
    return self.recv_getStorePricings()
3895 
 
3896 
  def send_getStorePricings(self, itemIds):
3897 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3898 
    args = getStorePricings_args()
3899 
    args.itemIds = itemIds
3900 
    args.write(self._oprot)
3901 
    self._oprot.writeMessageEnd()
3902 
    self._oprot.trans.flush()
3903 
 
3904 
  def recv_getStorePricings(self, ):
3905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3906 
    if mtype == TMessageType.EXCEPTION:
3907 
      x = TApplicationException()
3908 
      x.read(self._iprot)
3909 
      self._iprot.readMessageEnd()
3910 
      raise x
3911 
    result = getStorePricings_result()
3912 
    result.read(self._iprot)
3913 
    self._iprot.readMessageEnd()
3914 
    if result.success is not None:
3915 
      return result.success
3916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3917 
 
7382 rajveer 3918 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3919 
    """
3920 
    Parameters:
3921 
     - sp
7382 rajveer 3922 
     - allColors
7265 rajveer 3923 
    """
7382 rajveer 3924 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3925 
    self.recv_updateStorePricing()
7256 rajveer 3926 
 
7382 rajveer 3927 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3928 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3929 
    args = updateStorePricing_args()
3930 
    args.sp = sp
7382 rajveer 3931 
    args.allColors = allColors
7265 rajveer 3932 
    args.write(self._oprot)
3933 
    self._oprot.writeMessageEnd()
3934 
    self._oprot.trans.flush()
3935 
 
3936 
  def recv_updateStorePricing(self, ):
3937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3938 
    if mtype == TMessageType.EXCEPTION:
3939 
      x = TApplicationException()
3940 
      x.read(self._iprot)
3941 
      self._iprot.readMessageEnd()
3942 
      raise x
3943 
    result = updateStorePricing_result()
3944 
    result.read(self._iprot)
3945 
    self._iprot.readMessageEnd()
3946 
    return
3947 
 
7281 kshitij.so 3948 
  def getAllAmazonListedItems(self, ):
3949 
    self.send_getAllAmazonListedItems()
3950 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3951 
 
7281 kshitij.so 3952 
  def send_getAllAmazonListedItems(self, ):
3953 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3954 
    args = getAllAmazonListedItems_args()
3955 
    args.write(self._oprot)
3956 
    self._oprot.writeMessageEnd()
3957 
    self._oprot.trans.flush()
3958 
 
3959 
  def recv_getAllAmazonListedItems(self, ):
3960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3961 
    if mtype == TMessageType.EXCEPTION:
3962 
      x = TApplicationException()
3963 
      x.read(self._iprot)
3964 
      self._iprot.readMessageEnd()
3965 
      raise x
3966 
    result = getAllAmazonListedItems_result()
3967 
    result.read(self._iprot)
3968 
    self._iprot.readMessageEnd()
3969 
    if result.success is not None:
3970 
      return result.success
3971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3972 
 
3973 
  def getAmazonItemDetails(self, itemId):
3974 
    """
3975 
    Parameters:
3976 
     - itemId
3977 
    """
3978 
    self.send_getAmazonItemDetails(itemId)
3979 
    return self.recv_getAmazonItemDetails()
3980 
 
3981 
  def send_getAmazonItemDetails(self, itemId):
3982 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3983 
    args = getAmazonItemDetails_args()
3984 
    args.itemId = itemId
3985 
    args.write(self._oprot)
3986 
    self._oprot.writeMessageEnd()
3987 
    self._oprot.trans.flush()
3988 
 
3989 
  def recv_getAmazonItemDetails(self, ):
3990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3991 
    if mtype == TMessageType.EXCEPTION:
3992 
      x = TApplicationException()
3993 
      x.read(self._iprot)
3994 
      self._iprot.readMessageEnd()
3995 
      raise x
3996 
    result = getAmazonItemDetails_result()
3997 
    result.read(self._iprot)
3998 
    self._iprot.readMessageEnd()
3999 
    if result.success is not None:
4000 
      return result.success
4001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4002 
 
8168 kshitij.so 4003 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4004 
    """
4005 
    Parameters:
8168 kshitij.so 4006 
     - amazonlisted
7281 kshitij.so 4007 
    """
8168 kshitij.so 4008 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4009 
    self.recv_updateAmazonItemDetails()
4010 
 
8168 kshitij.so 4011 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4012 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4013 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4014 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_updateAmazonItemDetails(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = updateAmazonItemDetails_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
4029 
    return
4030 
 
4031 
  def addAmazonItem(self, amazonlisted):
4032 
    """
4033 
    Parameters:
4034 
     - amazonlisted
4035 
    """
4036 
    self.send_addAmazonItem(amazonlisted)
4037 
    self.recv_addAmazonItem()
4038 
 
4039 
  def send_addAmazonItem(self, amazonlisted):
4040 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4041 
    args = addAmazonItem_args()
4042 
    args.amazonlisted = amazonlisted
4043 
    args.write(self._oprot)
4044 
    self._oprot.writeMessageEnd()
4045 
    self._oprot.trans.flush()
4046 
 
4047 
  def recv_addAmazonItem(self, ):
4048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4049 
    if mtype == TMessageType.EXCEPTION:
4050 
      x = TApplicationException()
4051 
      x.read(self._iprot)
4052 
      self._iprot.readMessageEnd()
4053 
      raise x
4054 
    result = addAmazonItem_result()
4055 
    result.read(self._iprot)
4056 
    self._iprot.readMessageEnd()
4057 
    return
4058 
 
7291 vikram.rag 4059 
  def getAsinItems(self, ):
4060 
    self.send_getAsinItems()
4061 
    return self.recv_getAsinItems()
7281 kshitij.so 4062 
 
7291 vikram.rag 4063 
  def send_getAsinItems(self, ):
4064 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4065 
    args = getAsinItems_args()
4066 
    args.write(self._oprot)
4067 
    self._oprot.writeMessageEnd()
4068 
    self._oprot.trans.flush()
4069 
 
4070 
  def recv_getAsinItems(self, ):
4071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4072 
    if mtype == TMessageType.EXCEPTION:
4073 
      x = TApplicationException()
4074 
      x.read(self._iprot)
4075 
      self._iprot.readMessageEnd()
4076 
      raise x
4077 
    result = getAsinItems_result()
4078 
    result.read(self._iprot)
4079 
    self._iprot.readMessageEnd()
4080 
    if result.success is not None:
4081 
      return result.success
4082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4083 
 
4084 
  def getAllFbaListedItems(self, ):
4085 
    self.send_getAllFbaListedItems()
4086 
    return self.recv_getAllFbaListedItems()
4087 
 
4088 
  def send_getAllFbaListedItems(self, ):
4089 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4090 
    args = getAllFbaListedItems_args()
4091 
    args.write(self._oprot)
4092 
    self._oprot.writeMessageEnd()
4093 
    self._oprot.trans.flush()
4094 
 
4095 
  def recv_getAllFbaListedItems(self, ):
4096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4097 
    if mtype == TMessageType.EXCEPTION:
4098 
      x = TApplicationException()
4099 
      x.read(self._iprot)
4100 
      self._iprot.readMessageEnd()
4101 
      raise x
4102 
    result = getAllFbaListedItems_result()
4103 
    result.read(self._iprot)
4104 
    self._iprot.readMessageEnd()
4105 
    if result.success is not None:
4106 
      return result.success
4107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4108 
 
4109 
  def getAllNonFbaListedItems(self, ):
4110 
    self.send_getAllNonFbaListedItems()
4111 
    return self.recv_getAllNonFbaListedItems()
4112 
 
4113 
  def send_getAllNonFbaListedItems(self, ):
4114 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4115 
    args = getAllNonFbaListedItems_args()
4116 
    args.write(self._oprot)
4117 
    self._oprot.writeMessageEnd()
4118 
    self._oprot.trans.flush()
4119 
 
4120 
  def recv_getAllNonFbaListedItems(self, ):
4121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4122 
    if mtype == TMessageType.EXCEPTION:
4123 
      x = TApplicationException()
4124 
      x.read(self._iprot)
4125 
      self._iprot.readMessageEnd()
4126 
      raise x
4127 
    result = getAllNonFbaListedItems_result()
4128 
    result.read(self._iprot)
4129 
    self._iprot.readMessageEnd()
4130 
    if result.success is not None:
4131 
      return result.success
4132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4133 
 
7460 kshitij.so 4134 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4135 
    """
4136 
    Parameters:
4137 
     - itemId
4138 
     - holdInventory
4139 
     - defaultInventory
4140 
    """
4141 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4142 
    return self.recv_updateItemInventory()
7291 vikram.rag 4143 
 
7460 kshitij.so 4144 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4145 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4146 
    args = updateItemInventory_args()
4147 
    args.itemId = itemId
4148 
    args.holdInventory = holdInventory
4149 
    args.defaultInventory = defaultInventory
4150 
    args.write(self._oprot)
4151 
    self._oprot.writeMessageEnd()
4152 
    self._oprot.trans.flush()
4153 
 
4154 
  def recv_updateItemInventory(self, ):
4155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4156 
    if mtype == TMessageType.EXCEPTION:
4157 
      x = TApplicationException()
4158 
      x.read(self._iprot)
4159 
      self._iprot.readMessageEnd()
4160 
      raise x
4161 
    result = updateItemInventory_result()
4162 
    result.read(self._iprot)
4163 
    self._iprot.readMessageEnd()
4164 
    if result.success is not None:
4165 
      return result.success
4166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4167 
 
7770 kshitij.so 4168 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4169 
    """
4170 
    Parameters:
4171 
     - type
4172 
     - sku
4173 
     - timestamp
4174 
    """
4175 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4176 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4177 
 
7770 kshitij.so 4178 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4179 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4180 
    args = updateTimestampForAmazonFeeds_args()
4181 
    args.type = type
4182 
    args.sku = sku
4183 
    args.timestamp = timestamp
4184 
    args.write(self._oprot)
4185 
    self._oprot.writeMessageEnd()
4186 
    self._oprot.trans.flush()
4187 
 
4188 
  def recv_updateTimestampForAmazonFeeds(self, ):
4189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4190 
    if mtype == TMessageType.EXCEPTION:
4191 
      x = TApplicationException()
4192 
      x.read(self._iprot)
4193 
      self._iprot.readMessageEnd()
4194 
      raise x
4195 
    result = updateTimestampForAmazonFeeds_result()
4196 
    result.read(self._iprot)
4197 
    self._iprot.readMessageEnd()
4198 
    if result.success is not None:
4199 
      return result.success
4200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4201 
 
7897 amar.kumar 4202 
  def getAllParentCategories(self, ):
4203 
    self.send_getAllParentCategories()
4204 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4205 
 
7897 amar.kumar 4206 
  def send_getAllParentCategories(self, ):
4207 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4208 
    args = getAllParentCategories_args()
4209 
    args.write(self._oprot)
4210 
    self._oprot.writeMessageEnd()
4211 
    self._oprot.trans.flush()
4212 
 
4213 
  def recv_getAllParentCategories(self, ):
4214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4215 
    if mtype == TMessageType.EXCEPTION:
4216 
      x = TApplicationException()
4217 
      x.read(self._iprot)
4218 
      self._iprot.readMessageEnd()
4219 
      raise x
4220 
    result = getAllParentCategories_result()
4221 
    result.read(self._iprot)
4222 
    self._iprot.readMessageEnd()
4223 
    if result.success is not None:
4224 
      return result.success
4225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4226 
 
7977 kshitij.so 4227 
  def addPageViewEvent(self, pageViewEvents):
4228 
    """
4229 
    Parameters:
4230 
     - pageViewEvents
4231 
    """
4232 
    self.send_addPageViewEvent(pageViewEvents)
4233 
    self.recv_addPageViewEvent()
7897 amar.kumar 4234 
 
7977 kshitij.so 4235 
  def send_addPageViewEvent(self, pageViewEvents):
4236 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4237 
    args = addPageViewEvent_args()
4238 
    args.pageViewEvents = pageViewEvents
4239 
    args.write(self._oprot)
4240 
    self._oprot.writeMessageEnd()
4241 
    self._oprot.trans.flush()
4242 
 
4243 
  def recv_addPageViewEvent(self, ):
4244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4245 
    if mtype == TMessageType.EXCEPTION:
4246 
      x = TApplicationException()
4247 
      x.read(self._iprot)
4248 
      self._iprot.readMessageEnd()
4249 
      raise x
4250 
    result = addPageViewEvent_result()
4251 
    result.read(self._iprot)
4252 
    self._iprot.readMessageEnd()
4253 
    return
4254 
 
4255 
  def addCartEvent(self, cartEvents):
4256 
    """
4257 
    Parameters:
4258 
     - cartEvents
4259 
    """
4260 
    self.send_addCartEvent(cartEvents)
4261 
    self.recv_addCartEvent()
4262 
 
4263 
  def send_addCartEvent(self, cartEvents):
4264 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4265 
    args = addCartEvent_args()
4266 
    args.cartEvents = cartEvents
4267 
    args.write(self._oprot)
4268 
    self._oprot.writeMessageEnd()
4269 
    self._oprot.trans.flush()
4270 
 
4271 
  def recv_addCartEvent(self, ):
4272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4273 
    if mtype == TMessageType.EXCEPTION:
4274 
      x = TApplicationException()
4275 
      x.read(self._iprot)
4276 
      self._iprot.readMessageEnd()
4277 
      raise x
4278 
    result = addCartEvent_result()
4279 
    result.read(self._iprot)
4280 
    self._iprot.readMessageEnd()
4281 
    return
4282 
 
8182 amar.kumar 4283 
  def addEbayItem(self, ebayItem):
4284 
    """
4285 
    Parameters:
4286 
     - ebayItem
4287 
    """
4288 
    self.send_addEbayItem(ebayItem)
4289 
    self.recv_addEbayItem()
4290 
 
4291 
  def send_addEbayItem(self, ebayItem):
4292 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4293 
    args = addEbayItem_args()
4294 
    args.ebayItem = ebayItem
4295 
    args.write(self._oprot)
4296 
    self._oprot.writeMessageEnd()
4297 
    self._oprot.trans.flush()
4298 
 
4299 
  def recv_addEbayItem(self, ):
4300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4301 
    if mtype == TMessageType.EXCEPTION:
4302 
      x = TApplicationException()
4303 
      x.read(self._iprot)
4304 
      self._iprot.readMessageEnd()
4305 
      raise x
4306 
    result = addEbayItem_result()
4307 
    result.read(self._iprot)
4308 
    self._iprot.readMessageEnd()
4309 
    return
4310 
 
4311 
  def getEbayItem(self, listingId):
4312 
    """
4313 
    Parameters:
4314 
     - listingId
4315 
    """
4316 
    self.send_getEbayItem(listingId)
4317 
    return self.recv_getEbayItem()
4318 
 
4319 
  def send_getEbayItem(self, listingId):
4320 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4321 
    args = getEbayItem_args()
4322 
    args.listingId = listingId
4323 
    args.write(self._oprot)
4324 
    self._oprot.writeMessageEnd()
4325 
    self._oprot.trans.flush()
4326 
 
4327 
  def recv_getEbayItem(self, ):
4328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4329 
    if mtype == TMessageType.EXCEPTION:
4330 
      x = TApplicationException()
4331 
      x.read(self._iprot)
4332 
      self._iprot.readMessageEnd()
4333 
      raise x
4334 
    result = getEbayItem_result()
4335 
    result.read(self._iprot)
4336 
    self._iprot.readMessageEnd()
4337 
    if result.success is not None:
4338 
      return result.success
4339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4340 
 
4341 
  def updateEbayItem(self, ebayItem):
4342 
    """
4343 
    Parameters:
4344 
     - ebayItem
4345 
    """
4346 
    self.send_updateEbayItem(ebayItem)
4347 
    self.recv_updateEbayItem()
4348 
 
4349 
  def send_updateEbayItem(self, ebayItem):
4350 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4351 
    args = updateEbayItem_args()
4352 
    args.ebayItem = ebayItem
4353 
    args.write(self._oprot)
4354 
    self._oprot.writeMessageEnd()
4355 
    self._oprot.trans.flush()
4356 
 
4357 
  def recv_updateEbayItem(self, ):
4358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4359 
    if mtype == TMessageType.EXCEPTION:
4360 
      x = TApplicationException()
4361 
      x.read(self._iprot)
4362 
      self._iprot.readMessageEnd()
4363 
      raise x
4364 
    result = updateEbayItem_result()
4365 
    result.read(self._iprot)
4366 
    self._iprot.readMessageEnd()
4367 
    return
4368 
 
8139 kshitij.so 4369 
  def getAmazonListedItems(self, offset, limit):
4370 
    """
4371 
    Parameters:
4372 
     - offset
4373 
     - limit
4374 
    """
4375 
    self.send_getAmazonListedItems(offset, limit)
4376 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4377 
 
8139 kshitij.so 4378 
  def send_getAmazonListedItems(self, offset, limit):
4379 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4380 
    args = getAmazonListedItems_args()
4381 
    args.offset = offset
4382 
    args.limit = limit
4383 
    args.write(self._oprot)
4384 
    self._oprot.writeMessageEnd()
4385 
    self._oprot.trans.flush()
4386 
 
4387 
  def recv_getAmazonListedItems(self, ):
4388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4389 
    if mtype == TMessageType.EXCEPTION:
4390 
      x = TApplicationException()
4391 
      x.read(self._iprot)
4392 
      self._iprot.readMessageEnd()
4393 
      raise x
4394 
    result = getAmazonListedItems_result()
4395 
    result.read(self._iprot)
4396 
    self._iprot.readMessageEnd()
4397 
    if result.success is not None:
4398 
      return result.success
4399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4400 
 
8168 kshitij.so 4401 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4402 
    """
4403 
    Parameters:
4404 
     - amazonlisted
4405 
    """
4406 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4407 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4408 
 
8168 kshitij.so 4409 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4410 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4411 
    args = updateAmazonAttributesInBulk_args()
4412 
    args.amazonlisted = amazonlisted
4413 
    args.write(self._oprot)
4414 
    self._oprot.writeMessageEnd()
4415 
    self._oprot.trans.flush()
4416 
 
4417 
  def recv_updateAmazonAttributesInBulk(self, ):
4418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4419 
    if mtype == TMessageType.EXCEPTION:
4420 
      x = TApplicationException()
4421 
      x.read(self._iprot)
4422 
      self._iprot.readMessageEnd()
4423 
      raise x
4424 
    result = updateAmazonAttributesInBulk_result()
4425 
    result.read(self._iprot)
4426 
    self._iprot.readMessageEnd()
4427 
    if result.success is not None:
4428 
      return result.success
4429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4430 
 
8379 vikram.rag 4431 
  def getAllItemstoListOnFba(self, ):
4432 
    self.send_getAllItemstoListOnFba()
4433 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4434 
 
8379 vikram.rag 4435 
  def send_getAllItemstoListOnFba(self, ):
4436 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4437 
    args = getAllItemstoListOnFba_args()
4438 
    args.write(self._oprot)
4439 
    self._oprot.writeMessageEnd()
4440 
    self._oprot.trans.flush()
4441 
 
4442 
  def recv_getAllItemstoListOnFba(self, ):
4443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4444 
    if mtype == TMessageType.EXCEPTION:
4445 
      x = TApplicationException()
4446 
      x.read(self._iprot)
4447 
      self._iprot.readMessageEnd()
4448 
      raise x
4449 
    result = getAllItemstoListOnFba_result()
4450 
    result.read(self._iprot)
4451 
    self._iprot.readMessageEnd()
4452 
    if result.success is not None:
4453 
      return result.success
4454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4455 
 
4456 
  def getAllItemstoListOnNonFba(self, ):
4457 
    self.send_getAllItemstoListOnNonFba()
4458 
    return self.recv_getAllItemstoListOnNonFba()
4459 
 
4460 
  def send_getAllItemstoListOnNonFba(self, ):
4461 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4462 
    args = getAllItemstoListOnNonFba_args()
4463 
    args.write(self._oprot)
4464 
    self._oprot.writeMessageEnd()
4465 
    self._oprot.trans.flush()
4466 
 
4467 
  def recv_getAllItemstoListOnNonFba(self, ):
4468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4469 
    if mtype == TMessageType.EXCEPTION:
4470 
      x = TApplicationException()
4471 
      x.read(self._iprot)
4472 
      self._iprot.readMessageEnd()
4473 
      raise x
4474 
    result = getAllItemstoListOnNonFba_result()
4475 
    result.read(self._iprot)
4476 
    self._iprot.readMessageEnd()
4477 
    if result.success is not None:
4478 
      return result.success
4479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4480 
 
8616 vikram.rag 4481 
  def getAllSnapdealListedActiveItems(self, ):
4482 
    self.send_getAllSnapdealListedActiveItems()
4483 
    return self.recv_getAllSnapdealListedActiveItems()
8379 vikram.rag 4484 
 
8616 vikram.rag 4485 
  def send_getAllSnapdealListedActiveItems(self, ):
4486 
    self._oprot.writeMessageBegin('getAllSnapdealListedActiveItems', TMessageType.CALL, self._seqid)
4487 
    args = getAllSnapdealListedActiveItems_args()
4488 
    args.write(self._oprot)
4489 
    self._oprot.writeMessageEnd()
4490 
    self._oprot.trans.flush()
4491 
 
4492 
  def recv_getAllSnapdealListedActiveItems(self, ):
4493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4494 
    if mtype == TMessageType.EXCEPTION:
4495 
      x = TApplicationException()
4496 
      x.read(self._iprot)
4497 
      self._iprot.readMessageEnd()
4498 
      raise x
4499 
    result = getAllSnapdealListedActiveItems_result()
4500 
    result.read(self._iprot)
4501 
    self._iprot.readMessageEnd()
4502 
    if result.success is not None:
4503 
      return result.success
4504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealListedActiveItems failed: unknown result");
4505 
 
4506 
 
5944 mandeep.dh 4507 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4508 
  def __init__(self, handler):
4509 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4510 
    self._processMap["addItem"] = Processor.process_addItem
4511 
    self._processMap["updateItem"] = Processor.process_updateItem
4512 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4513 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4514 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4515 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4516 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4517 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4518 
    self._processMap["getItem"] = Processor.process_getItem
4519 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4520 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4521 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4522 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4523 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4524 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4525 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4526 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4527 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4528 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4529 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4530 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4531 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4532 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4533 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4534 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4535 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4536 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4537 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4538 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4539 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4540 
    self._processMap["addCategory"] = Processor.process_addCategory
4541 
    self._processMap["getCategory"] = Processor.process_getCategory
4542 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4543 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4544 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4545 
    self._processMap["addTag"] = Processor.process_addTag
4546 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4547 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4548 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4549 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4550 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4551 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4552 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4553 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4554 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4555 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4556 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4557 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 4558 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 4559 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4560 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 4561 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
4562 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
4563 
    self._processMap["addCampaign"] = Processor.process_addCampaign
4564 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
4565 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
4566 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
5944 mandeep.dh 4567 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4568 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4569 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4570 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4571 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4572 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4573 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4574 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4575 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4576 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4577 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4578 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4579 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4580 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4581 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4582 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4583 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4584 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4585 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4586 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4587 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4588 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4589 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4590 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4591 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4592 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4593 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4594 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4595 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4596 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4597 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4598 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4599 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4600 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4601 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4602 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4603 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4604 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4605 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4606 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4607 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4608 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4609 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4610 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4611 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4612 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4613 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4614 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4615 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4616 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4617 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4618 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4619 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4620 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4621 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4622 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4623 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4624 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4625 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4626 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8616 vikram.rag 4627 
    self._processMap["getAllSnapdealListedActiveItems"] = Processor.process_getAllSnapdealListedActiveItems
5944 mandeep.dh 4628 
 
4629 
  def process(self, iprot, oprot):
4630 
    (name, type, seqid) = iprot.readMessageBegin()
4631 
    if name not in self._processMap:
4632 
      iprot.skip(TType.STRUCT)
4633 
      iprot.readMessageEnd()
4634 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4635 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4636 
      x.write(oprot)
4637 
      oprot.writeMessageEnd()
4638 
      oprot.trans.flush()
4639 
      return
4640 
    else:
4641 
      self._processMap[name](self, seqid, iprot, oprot)
4642 
    return True
4643 
 
4644 
  def process_addItem(self, seqid, iprot, oprot):
4645 
    args = addItem_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = addItem_result()
4649 
    try:
4650 
      result.success = self._handler.addItem(args.item)
4651 
    except CatalogServiceException, cex:
4652 
      result.cex = cex
4653 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4654 
    result.write(oprot)
4655 
    oprot.writeMessageEnd()
4656 
    oprot.trans.flush()
4657 
 
4658 
  def process_updateItem(self, seqid, iprot, oprot):
4659 
    args = updateItem_args()
4660 
    args.read(iprot)
4661 
    iprot.readMessageEnd()
4662 
    result = updateItem_result()
4663 
    try:
4664 
      result.success = self._handler.updateItem(args.item)
4665 
    except CatalogServiceException, cex:
4666 
      result.cex = cex
4667 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4668 
    result.write(oprot)
4669 
    oprot.writeMessageEnd()
4670 
    oprot.trans.flush()
4671 
 
4672 
  def process_isActive(self, seqid, iprot, oprot):
4673 
    args = isActive_args()
4674 
    args.read(iprot)
4675 
    iprot.readMessageEnd()
4676 
    result = isActive_result()
4677 
    try:
4678 
      result.success = self._handler.isActive(args.itemId)
4679 
    except CatalogServiceException, isex:
4680 
      result.isex = isex
4681 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4682 
    result.write(oprot)
4683 
    oprot.writeMessageEnd()
4684 
    oprot.trans.flush()
4685 
 
7438 amit.gupta 4686 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4687 
    args = getItemsStatus_args()
4688 
    args.read(iprot)
4689 
    iprot.readMessageEnd()
4690 
    result = getItemsStatus_result()
4691 
    try:
4692 
      result.success = self._handler.getItemsStatus(args.itemIds)
4693 
    except CatalogServiceException, isex:
4694 
      result.isex = isex
4695 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4696 
    result.write(oprot)
4697 
    oprot.writeMessageEnd()
4698 
    oprot.trans.flush()
4699 
 
5944 mandeep.dh 4700 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4701 
    args = getItemStatusDescription_args()
4702 
    args.read(iprot)
4703 
    iprot.readMessageEnd()
4704 
    result = getItemStatusDescription_result()
4705 
    try:
4706 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4707 
    except CatalogServiceException, isex:
4708 
      result.isex = isex
4709 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4710 
    result.write(oprot)
4711 
    oprot.writeMessageEnd()
4712 
    oprot.trans.flush()
4713 
 
4714 
  def process_startItemOn(self, seqid, iprot, oprot):
4715 
    args = startItemOn_args()
4716 
    args.read(iprot)
4717 
    iprot.readMessageEnd()
4718 
    result = startItemOn_result()
4719 
    try:
4720 
      self._handler.startItemOn(args.item_id, args.timestamp)
4721 
    except CatalogServiceException, cex:
4722 
      result.cex = cex
4723 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4724 
    result.write(oprot)
4725 
    oprot.writeMessageEnd()
4726 
    oprot.trans.flush()
4727 
 
4728 
  def process_retireItemOn(self, seqid, iprot, oprot):
4729 
    args = retireItemOn_args()
4730 
    args.read(iprot)
4731 
    iprot.readMessageEnd()
4732 
    result = retireItemOn_result()
4733 
    try:
4734 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4735 
    except CatalogServiceException, cex:
4736 
      result.cex = cex
4737 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4741 
 
4742 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4743 
    args = changeItemStatus_args()
4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
4746 
    result = changeItemStatus_result()
4747 
    try:
4748 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4749 
    except CatalogServiceException, cex:
4750 
      result.cex = cex
4751 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4752 
    result.write(oprot)
4753 
    oprot.writeMessageEnd()
4754 
    oprot.trans.flush()
4755 
 
4756 
  def process_getItem(self, seqid, iprot, oprot):
4757 
    args = getItem_args()
4758 
    args.read(iprot)
4759 
    iprot.readMessageEnd()
4760 
    result = getItem_result()
4761 
    try:
4762 
      result.success = self._handler.getItem(args.item_id)
4763 
    except CatalogServiceException, cex:
4764 
      result.cex = cex
4765 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
4770 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4771 
    args = getItemsByCatalogId_args()
4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
4774 
    result = getItemsByCatalogId_result()
4775 
    try:
4776 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4777 
    except CatalogServiceException, cex:
4778 
      result.cex = cex
4779 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4780 
    result.write(oprot)
4781 
    oprot.writeMessageEnd()
4782 
    oprot.trans.flush()
4783 
 
4784 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4785 
    args = getValidItemsByCatalogId_args()
4786 
    args.read(iprot)
4787 
    iprot.readMessageEnd()
4788 
    result = getValidItemsByCatalogId_result()
4789 
    try:
4790 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4791 
    except CatalogServiceException, cex:
4792 
      result.cex = cex
4793 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4794 
    result.write(oprot)
4795 
    oprot.writeMessageEnd()
4796 
    oprot.trans.flush()
4797 
 
4798 
  def process_getAllItems(self, seqid, iprot, oprot):
4799 
    args = getAllItems_args()
4800 
    args.read(iprot)
4801 
    iprot.readMessageEnd()
4802 
    result = getAllItems_result()
4803 
    try:
4804 
      result.success = self._handler.getAllItems(args.isActive)
4805 
    except CatalogServiceException, cex:
4806 
      result.cex = cex
4807 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4808 
    result.write(oprot)
4809 
    oprot.writeMessageEnd()
4810 
    oprot.trans.flush()
4811 
 
4812 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4813 
    args = getAllItemsByStatus_args()
4814 
    args.read(iprot)
4815 
    iprot.readMessageEnd()
4816 
    result = getAllItemsByStatus_result()
4817 
    try:
4818 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4819 
    except CatalogServiceException, cex:
4820 
      result.cex = cex
4821 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4822 
    result.write(oprot)
4823 
    oprot.writeMessageEnd()
4824 
    oprot.trans.flush()
4825 
 
4826 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4827 
    args = markItemAsContentComplete_args()
4828 
    args.read(iprot)
4829 
    iprot.readMessageEnd()
4830 
    result = markItemAsContentComplete_result()
4831 
    try:
4832 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4833 
    except CatalogServiceException, cex:
4834 
      result.cex = cex
4835 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4836 
    result.write(oprot)
4837 
    oprot.writeMessageEnd()
4838 
    oprot.trans.flush()
4839 
 
4840 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4841 
    args = getAllItemsInRange_args()
4842 
    args.read(iprot)
4843 
    iprot.readMessageEnd()
4844 
    result = getAllItemsInRange_result()
4845 
    try:
4846 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4847 
    except CatalogServiceException, cex:
4848 
      result.cex = cex
4849 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4850 
    result.write(oprot)
4851 
    oprot.writeMessageEnd()
4852 
    oprot.trans.flush()
4853 
 
4854 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4855 
    args = getAllItemsByStatusInRange_args()
4856 
    args.read(iprot)
4857 
    iprot.readMessageEnd()
4858 
    result = getAllItemsByStatusInRange_result()
4859 
    try:
4860 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4861 
    except CatalogServiceException, cex:
4862 
      result.cex = cex
4863 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4864 
    result.write(oprot)
4865 
    oprot.writeMessageEnd()
4866 
    oprot.trans.flush()
4867 
 
4868 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4869 
    args = getItemCountByStatus_args()
4870 
    args.read(iprot)
4871 
    iprot.readMessageEnd()
4872 
    result = getItemCountByStatus_result()
4873 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4874 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4875 
    result.write(oprot)
4876 
    oprot.writeMessageEnd()
4877 
    oprot.trans.flush()
4878 
 
4879 
  def process_getBestSellers(self, seqid, iprot, oprot):
4880 
    args = getBestSellers_args()
4881 
    args.read(iprot)
4882 
    iprot.readMessageEnd()
4883 
    result = getBestSellers_result()
4884 
    try:
4885 
      result.success = self._handler.getBestSellers()
4886 
    except CatalogServiceException, isex:
4887 
      result.isex = isex
4888 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4889 
    result.write(oprot)
4890 
    oprot.writeMessageEnd()
4891 
    oprot.trans.flush()
4892 
 
4893 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4894 
    args = getBestSellersCatalogIds_args()
4895 
    args.read(iprot)
4896 
    iprot.readMessageEnd()
4897 
    result = getBestSellersCatalogIds_result()
4898 
    try:
4899 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4900 
    except CatalogServiceException, cex:
4901 
      result.cex = cex
4902 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4903 
    result.write(oprot)
4904 
    oprot.writeMessageEnd()
4905 
    oprot.trans.flush()
4906 
 
4907 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4908 
    args = getBestSellersCount_args()
4909 
    args.read(iprot)
4910 
    iprot.readMessageEnd()
4911 
    result = getBestSellersCount_result()
4912 
    try:
4913 
      result.success = self._handler.getBestSellersCount()
4914 
    except CatalogServiceException, cex:
4915 
      result.cex = cex
4916 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
4920 
 
4921 
  def process_getBestDeals(self, seqid, iprot, oprot):
4922 
    args = getBestDeals_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = getBestDeals_result()
4926 
    try:
4927 
      result.success = self._handler.getBestDeals()
4928 
    except CatalogServiceException, isex:
4929 
      result.isex = isex
4930 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4931 
    result.write(oprot)
4932 
    oprot.writeMessageEnd()
4933 
    oprot.trans.flush()
4934 
 
4935 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4936 
    args = getBestDealsCatalogIds_args()
4937 
    args.read(iprot)
4938 
    iprot.readMessageEnd()
4939 
    result = getBestDealsCatalogIds_result()
4940 
    try:
4941 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4942 
    except CatalogServiceException, cex:
4943 
      result.cex = cex
4944 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4948 
 
4949 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4950 
    args = getBestDealsCount_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = getBestDealsCount_result()
4954 
    try:
4955 
      result.success = self._handler.getBestDealsCount()
4956 
    except CatalogServiceException, cex:
4957 
      result.cex = cex
4958 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
4962 
 
4963 
  def process_getComingSoon(self, seqid, iprot, oprot):
4964 
    args = getComingSoon_args()
4965 
    args.read(iprot)
4966 
    iprot.readMessageEnd()
4967 
    result = getComingSoon_result()
4968 
    try:
4969 
      result.success = self._handler.getComingSoon()
4970 
    except CatalogServiceException, isex:
4971 
      result.isex = isex
4972 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4973 
    result.write(oprot)
4974 
    oprot.writeMessageEnd()
4975 
    oprot.trans.flush()
4976 
 
4977 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4978 
    args = getComingSoonCatalogIds_args()
4979 
    args.read(iprot)
4980 
    iprot.readMessageEnd()
4981 
    result = getComingSoonCatalogIds_result()
4982 
    try:
4983 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4984 
    except CatalogServiceException, cex:
4985 
      result.cex = cex
4986 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4987 
    result.write(oprot)
4988 
    oprot.writeMessageEnd()
4989 
    oprot.trans.flush()
4990 
 
4991 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4992 
    args = getComingSoonCount_args()
4993 
    args.read(iprot)
4994 
    iprot.readMessageEnd()
4995 
    result = getComingSoonCount_result()
4996 
    try:
4997 
      result.success = self._handler.getComingSoonCount()
4998 
    except CatalogServiceException, cex:
4999 
      result.cex = cex
5000 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5001 
    result.write(oprot)
5002 
    oprot.writeMessageEnd()
5003 
    oprot.trans.flush()
5004 
 
5005 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5006 
    args = getLatestArrivals_args()
5007 
    args.read(iprot)
5008 
    iprot.readMessageEnd()
5009 
    result = getLatestArrivals_result()
5010 
    try:
5011 
      result.success = self._handler.getLatestArrivals()
5012 
    except CatalogServiceException, isex:
5013 
      result.isex = isex
5014 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5015 
    result.write(oprot)
5016 
    oprot.writeMessageEnd()
5017 
    oprot.trans.flush()
5018 
 
5019 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5020 
    args = getLatestArrivalsCatalogIds_args()
5021 
    args.read(iprot)
5022 
    iprot.readMessageEnd()
5023 
    result = getLatestArrivalsCatalogIds_result()
5024 
    try:
5025 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5026 
    except CatalogServiceException, cex:
5027 
      result.cex = cex
5028 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5029 
    result.write(oprot)
5030 
    oprot.writeMessageEnd()
5031 
    oprot.trans.flush()
5032 
 
5033 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5034 
    args = getLatestArrivalsCount_args()
5035 
    args.read(iprot)
5036 
    iprot.readMessageEnd()
5037 
    result = getLatestArrivalsCount_result()
5038 
    try:
5039 
      result.success = self._handler.getLatestArrivalsCount()
5040 
    except CatalogServiceException, cex:
5041 
      result.cex = cex
5042 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5043 
    result.write(oprot)
5044 
    oprot.writeMessageEnd()
5045 
    oprot.trans.flush()
5046 
 
5047 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5048 
    args = generateNewEntityID_args()
5049 
    args.read(iprot)
5050 
    iprot.readMessageEnd()
5051 
    result = generateNewEntityID_result()
5052 
    result.success = self._handler.generateNewEntityID()
5053 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5054 
    result.write(oprot)
5055 
    oprot.writeMessageEnd()
5056 
    oprot.trans.flush()
5057 
 
5058 
  def process_addCategory(self, seqid, iprot, oprot):
5059 
    args = addCategory_args()
5060 
    args.read(iprot)
5061 
    iprot.readMessageEnd()
5062 
    result = addCategory_result()
5063 
    result.success = self._handler.addCategory(args.category)
5064 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5065 
    result.write(oprot)
5066 
    oprot.writeMessageEnd()
5067 
    oprot.trans.flush()
5068 
 
5069 
  def process_getCategory(self, seqid, iprot, oprot):
5070 
    args = getCategory_args()
5071 
    args.read(iprot)
5072 
    iprot.readMessageEnd()
5073 
    result = getCategory_result()
5074 
    result.success = self._handler.getCategory(args.id)
5075 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
5079 
 
5080 
  def process_getAllCategories(self, seqid, iprot, oprot):
5081 
    args = getAllCategories_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = getAllCategories_result()
5085 
    result.success = self._handler.getAllCategories()
5086 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
5090 
 
5091 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5092 
    args = getAllSimilarItems_args()
5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
5095 
    result = getAllSimilarItems_result()
5096 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5097 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
5101 
 
5102 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5103 
    args = addSimilarItem_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = addSimilarItem_result()
5107 
    try:
5108 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5109 
    except CatalogServiceException, cex:
5110 
      result.cex = cex
5111 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5112 
    result.write(oprot)
5113 
    oprot.writeMessageEnd()
5114 
    oprot.trans.flush()
5115 
 
6512 kshitij.so 5116 
  def process_addTag(self, seqid, iprot, oprot):
5117 
    args = addTag_args()
5118 
    args.read(iprot)
5119 
    iprot.readMessageEnd()
5120 
    result = addTag_result()
5121 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5122 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5123 
    result.write(oprot)
5124 
    oprot.writeMessageEnd()
5125 
    oprot.trans.flush()
5126 
 
5127 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5128 
    args = deleteEntityTag_args()
5129 
    args.read(iprot)
5130 
    iprot.readMessageEnd()
5131 
    result = deleteEntityTag_result()
5132 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5133 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5134 
    result.write(oprot)
5135 
    oprot.writeMessageEnd()
5136 
    oprot.trans.flush()
5137 
 
5138 
  def process_deleteTag(self, seqid, iprot, oprot):
5139 
    args = deleteTag_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = deleteTag_result()
5143 
    result.success = self._handler.deleteTag(args.displayName)
5144 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5145 
    result.write(oprot)
5146 
    oprot.writeMessageEnd()
5147 
    oprot.trans.flush()
5148 
 
5149 
  def process_getAllTags(self, seqid, iprot, oprot):
5150 
    args = getAllTags_args()
5151 
    args.read(iprot)
5152 
    iprot.readMessageEnd()
5153 
    result = getAllTags_result()
5154 
    result.success = self._handler.getAllTags()
5155 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5156 
    result.write(oprot)
5157 
    oprot.writeMessageEnd()
5158 
    oprot.trans.flush()
5159 
 
5160 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5161 
    args = getAllEntitiesByTagName_args()
5162 
    args.read(iprot)
5163 
    iprot.readMessageEnd()
5164 
    result = getAllEntitiesByTagName_result()
5165 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5166 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5167 
    result.write(oprot)
5168 
    oprot.writeMessageEnd()
5169 
    oprot.trans.flush()
5170 
 
6845 amit.gupta 5171 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5172 
    args = getAllEntityTags_args()
5173 
    args.read(iprot)
5174 
    iprot.readMessageEnd()
5175 
    result = getAllEntityTags_result()
5176 
    result.success = self._handler.getAllEntityTags()
5177 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5178 
    result.write(oprot)
5179 
    oprot.writeMessageEnd()
5180 
    oprot.trans.flush()
5181 
 
6850 kshitij.so 5182 
  def process_addBanner(self, seqid, iprot, oprot):
5183 
    args = addBanner_args()
5184 
    args.read(iprot)
5185 
    iprot.readMessageEnd()
5186 
    result = addBanner_result()
8590 kshitij.so 5187 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5188 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5189 
    result.write(oprot)
5190 
    oprot.writeMessageEnd()
5191 
    oprot.trans.flush()
5192 
 
8579 kshitij.so 5193 
  def process_updateBanner(self, seqid, iprot, oprot):
5194 
    args = updateBanner_args()
5195 
    args.read(iprot)
5196 
    iprot.readMessageEnd()
5197 
    result = updateBanner_result()
5198 
    result.success = self._handler.updateBanner(args.banner)
5199 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5200 
    result.write(oprot)
5201 
    oprot.writeMessageEnd()
5202 
    oprot.trans.flush()
5203 
 
6850 kshitij.so 5204 
  def process_getAllBanners(self, seqid, iprot, oprot):
5205 
    args = getAllBanners_args()
5206 
    args.read(iprot)
5207 
    iprot.readMessageEnd()
5208 
    result = getAllBanners_result()
5209 
    result.success = self._handler.getAllBanners()
5210 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5211 
    result.write(oprot)
5212 
    oprot.writeMessageEnd()
5213 
    oprot.trans.flush()
5214 
 
5215 
  def process_deleteBanner(self, seqid, iprot, oprot):
5216 
    args = deleteBanner_args()
5217 
    args.read(iprot)
5218 
    iprot.readMessageEnd()
5219 
    result = deleteBanner_result()
5220 
    result.success = self._handler.deleteBanner(args.bannerName)
5221 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5222 
    result.write(oprot)
5223 
    oprot.writeMessageEnd()
5224 
    oprot.trans.flush()
5225 
 
5226 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5227 
    args = getBannerDetails_args()
5228 
    args.read(iprot)
5229 
    iprot.readMessageEnd()
5230 
    result = getBannerDetails_result()
5231 
    result.success = self._handler.getBannerDetails(args.bannerName)
5232 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5233 
    result.write(oprot)
5234 
    oprot.writeMessageEnd()
5235 
    oprot.trans.flush()
5236 
 
5237 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5238 
    args = getActiveBanners_args()
5239 
    args.read(iprot)
5240 
    iprot.readMessageEnd()
5241 
    result = getActiveBanners_result()
5242 
    result.success = self._handler.getActiveBanners()
5243 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5244 
    result.write(oprot)
5245 
    oprot.writeMessageEnd()
5246 
    oprot.trans.flush()
5247 
 
6849 kshitij.so 5248 
  def process_addBannerMap(self, seqid, iprot, oprot):
5249 
    args = addBannerMap_args()
5250 
    args.read(iprot)
5251 
    iprot.readMessageEnd()
5252 
    result = addBannerMap_result()
8579 kshitij.so 5253 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5254 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5255 
    result.write(oprot)
5256 
    oprot.writeMessageEnd()
5257 
    oprot.trans.flush()
5258 
 
8579 kshitij.so 5259 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5260 
    args = updateBannerMap_args()
5261 
    args.read(iprot)
5262 
    iprot.readMessageEnd()
5263 
    result = updateBannerMap_result()
5264 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5265 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
6849 kshitij.so 5270 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5271 
    args = deleteBannerMap_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = deleteBannerMap_result()
5275 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5276 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
5280 
 
5281 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5282 
    args = getBannerMapDetails_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = getBannerMapDetails_result()
5286 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
5287 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
5291 
 
8579 kshitij.so 5292 
  def process_addBannerUri(self, seqid, iprot, oprot):
5293 
    args = addBannerUri_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = addBannerUri_result()
5297 
    self._handler.addBannerUri(args.bannerUriMappings)
5298 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
5302 
 
5303 
  def process_getUriMapping(self, seqid, iprot, oprot):
5304 
    args = getUriMapping_args()
5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
5307 
    result = getUriMapping_result()
5308 
    result.success = self._handler.getUriMapping(args.bannerName)
5309 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
5313 
 
5314 
  def process_addCampaign(self, seqid, iprot, oprot):
5315 
    args = addCampaign_args()
5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
5318 
    result = addCampaign_result()
5319 
    self._handler.addCampaign(args.campaign)
5320 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5321 
    result.write(oprot)
5322 
    oprot.writeMessageEnd()
5323 
    oprot.trans.flush()
5324 
 
5325 
  def process_getCampaigns(self, seqid, iprot, oprot):
5326 
    args = getCampaigns_args()
5327 
    args.read(iprot)
5328 
    iprot.readMessageEnd()
5329 
    result = getCampaigns_result()
5330 
    result.success = self._handler.getCampaigns(args.campaignName)
5331 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5332 
    result.write(oprot)
5333 
    oprot.writeMessageEnd()
5334 
    oprot.trans.flush()
5335 
 
5336 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5337 
    args = deleteCampaign_args()
5338 
    args.read(iprot)
5339 
    iprot.readMessageEnd()
5340 
    result = deleteCampaign_result()
5341 
    self._handler.deleteCampaign(args.campaignId)
5342 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5343 
    result.write(oprot)
5344 
    oprot.writeMessageEnd()
5345 
    oprot.trans.flush()
5346 
 
5347 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5348 
    args = getAllCampaigns_args()
5349 
    args.read(iprot)
5350 
    iprot.readMessageEnd()
5351 
    result = getAllCampaigns_result()
5352 
    result.success = self._handler.getAllCampaigns()
5353 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5354 
    result.write(oprot)
5355 
    oprot.writeMessageEnd()
5356 
    oprot.trans.flush()
5357 
 
5944 mandeep.dh 5358 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5359 
    args = deleteSimilarItem_args()
5360 
    args.read(iprot)
5361 
    iprot.readMessageEnd()
5362 
    result = deleteSimilarItem_result()
5363 
    try:
5364 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5365 
    except CatalogServiceException, cex:
5366 
      result.cex = cex
5367 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5368 
    result.write(oprot)
5369 
    oprot.writeMessageEnd()
5370 
    oprot.trans.flush()
5371 
 
5372 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5373 
    args = checkSimilarItem_args()
5374 
    args.read(iprot)
5375 
    iprot.readMessageEnd()
5376 
    result = checkSimilarItem_result()
5377 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5378 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5379 
    result.write(oprot)
5380 
    oprot.writeMessageEnd()
5381 
    oprot.trans.flush()
5382 
 
5383 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5384 
    args = validateRiskyStatus_args()
5385 
    args.read(iprot)
5386 
    iprot.readMessageEnd()
5387 
    result = validateRiskyStatus_result()
5388 
    self._handler.validateRiskyStatus(args.itemId)
5389 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5390 
    result.write(oprot)
5391 
    oprot.writeMessageEnd()
5392 
    oprot.trans.flush()
5393 
 
5394 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5395 
    args = changeItemRiskyFlag_args()
5396 
    args.read(iprot)
5397 
    iprot.readMessageEnd()
5398 
    result = changeItemRiskyFlag_result()
5399 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5400 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5401 
    result.write(oprot)
5402 
    oprot.writeMessageEnd()
5403 
    oprot.trans.flush()
5404 
 
5405 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5406 
    args = getItemsByRiskyFlag_args()
5407 
    args.read(iprot)
5408 
    iprot.readMessageEnd()
5409 
    result = getItemsByRiskyFlag_result()
5410 
    result.success = self._handler.getItemsByRiskyFlag()
5411 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5412 
    result.write(oprot)
5413 
    oprot.writeMessageEnd()
5414 
    oprot.trans.flush()
5415 
 
5416 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5417 
    args = getItemsForMasterSheet_args()
5418 
    args.read(iprot)
5419 
    iprot.readMessageEnd()
5420 
    result = getItemsForMasterSheet_result()
5421 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5422 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5423 
    result.write(oprot)
5424 
    oprot.writeMessageEnd()
5425 
    oprot.trans.flush()
5426 
 
5427 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5428 
    args = getSimilarItemsCatalogIds_args()
5429 
    args.read(iprot)
5430 
    iprot.readMessageEnd()
5431 
    result = getSimilarItemsCatalogIds_result()
5432 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5433 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5434 
    result.write(oprot)
5435 
    oprot.writeMessageEnd()
5436 
    oprot.trans.flush()
5437 
 
5438 
  def process_addProductNotification(self, seqid, iprot, oprot):
5439 
    args = addProductNotification_args()
5440 
    args.read(iprot)
5441 
    iprot.readMessageEnd()
5442 
    result = addProductNotification_result()
5443 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5444 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5445 
    result.write(oprot)
5446 
    oprot.writeMessageEnd()
5447 
    oprot.trans.flush()
5448 
 
5449 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5450 
    args = sendProductNotifications_args()
5451 
    args.read(iprot)
5452 
    iprot.readMessageEnd()
5453 
    result = sendProductNotifications_result()
5454 
    result.success = self._handler.sendProductNotifications()
5455 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5456 
    result.write(oprot)
5457 
    oprot.writeMessageEnd()
5458 
    oprot.trans.flush()
5459 
 
5460 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5461 
    args = getAllBrandsByCategory_args()
5462 
    args.read(iprot)
5463 
    iprot.readMessageEnd()
5464 
    result = getAllBrandsByCategory_result()
5465 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5466 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5467 
    result.write(oprot)
5468 
    oprot.writeMessageEnd()
5469 
    oprot.trans.flush()
5470 
 
5471 
  def process_getAllBrands(self, seqid, iprot, oprot):
5472 
    args = getAllBrands_args()
5473 
    args.read(iprot)
5474 
    iprot.readMessageEnd()
5475 
    result = getAllBrands_result()
5476 
    result.success = self._handler.getAllBrands()
5477 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5478 
    result.write(oprot)
5479 
    oprot.writeMessageEnd()
5480 
    oprot.trans.flush()
5481 
 
5482 
  def process_getAllSources(self, seqid, iprot, oprot):
5483 
    args = getAllSources_args()
5484 
    args.read(iprot)
5485 
    iprot.readMessageEnd()
5486 
    result = getAllSources_result()
5487 
    result.success = self._handler.getAllSources()
5488 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5489 
    result.write(oprot)
5490 
    oprot.writeMessageEnd()
5491 
    oprot.trans.flush()
5492 
 
5493 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5494 
    args = getItemPricingBySource_args()
5495 
    args.read(iprot)
5496 
    iprot.readMessageEnd()
5497 
    result = getItemPricingBySource_result()
5498 
    try:
5499 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5500 
    except CatalogServiceException, cex:
5501 
      result.cex = cex
5502 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5503 
    result.write(oprot)
5504 
    oprot.writeMessageEnd()
5505 
    oprot.trans.flush()
5506 
 
5507 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5508 
    args = addSourceItemPricing_args()
5509 
    args.read(iprot)
5510 
    iprot.readMessageEnd()
5511 
    result = addSourceItemPricing_result()
5512 
    try:
5513 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5514 
    except CatalogServiceException, cex:
5515 
      result.cex = cex
5516 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5517 
    result.write(oprot)
5518 
    oprot.writeMessageEnd()
5519 
    oprot.trans.flush()
5520 
 
5521 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5522 
    args = getAllSourcePricing_args()
5523 
    args.read(iprot)
5524 
    iprot.readMessageEnd()
5525 
    result = getAllSourcePricing_result()
5526 
    try:
5527 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5528 
    except CatalogServiceException, cex:
5529 
      result.cex = cex
5530 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5531 
    result.write(oprot)
5532 
    oprot.writeMessageEnd()
5533 
    oprot.trans.flush()
5534 
 
5535 
  def process_getItemForSource(self, seqid, iprot, oprot):
5536 
    args = getItemForSource_args()
5537 
    args.read(iprot)
5538 
    iprot.readMessageEnd()
5539 
    result = getItemForSource_result()
5540 
    try:
5541 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5542 
    except CatalogServiceException, cex:
5543 
      result.cex = cex
5544 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5545 
    result.write(oprot)
5546 
    oprot.writeMessageEnd()
5547 
    oprot.trans.flush()
5548 
 
5549 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5550 
    args = searchItemsInRange_args()
5551 
    args.read(iprot)
5552 
    iprot.readMessageEnd()
5553 
    result = searchItemsInRange_result()
5554 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5555 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5556 
    result.write(oprot)
5557 
    oprot.writeMessageEnd()
5558 
    oprot.trans.flush()
5559 
 
5560 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5561 
    args = getSearchResultCount_args()
5562 
    args.read(iprot)
5563 
    iprot.readMessageEnd()
5564 
    result = getSearchResultCount_result()
5565 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5566 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
5570 
 
5571 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5572 
    args = getProductNotifications_args()
5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
5575 
    result = getProductNotifications_result()
5576 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5577 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
5581 
 
5582 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5583 
    args = getProductNotificationRequestCount_args()
5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
5586 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5587 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5588 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5589 
    result.write(oprot)
5590 
    oprot.writeMessageEnd()
5591 
    oprot.trans.flush()
5592 
 
5593 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5594 
    args = addAuthorizationLog_args()
5595 
    args.read(iprot)
5596 
    iprot.readMessageEnd()
5597 
    result = addAuthorizationLog_result()
5598 
    try:
5599 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5600 
    except CatalogServiceException, cex:
5601 
      result.cex = cex
5602 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
5607 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5608 
    args = addupdateVoucherForItem_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = addupdateVoucherForItem_result()
5612 
    try:
5613 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5614 
    except CatalogServiceException, cex:
5615 
      result.cex = cex
5616 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
5620 
 
5621 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5622 
    args = deleteVoucherForItem_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = deleteVoucherForItem_result()
5626 
    try:
5627 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5628 
    except CatalogServiceException, cex:
5629 
      result.cex = cex
5630 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
5634 
 
5635 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5636 
    args = getVoucherAmount_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = getVoucherAmount_result()
5640 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5641 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5642 
    result.write(oprot)
5643 
    oprot.writeMessageEnd()
5644 
    oprot.trans.flush()
5645 
 
5646 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5647 
    args = getAllItemVouchers_args()
5648 
    args.read(iprot)
5649 
    iprot.readMessageEnd()
5650 
    result = getAllItemVouchers_result()
5651 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5652 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5653 
    result.write(oprot)
5654 
    oprot.writeMessageEnd()
5655 
    oprot.trans.flush()
5656 
 
5657 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5658 
    args = isValidCatalogItemId_args()
5659 
    args.read(iprot)
5660 
    iprot.readMessageEnd()
5661 
    result = isValidCatalogItemId_result()
5662 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5663 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5664 
    result.write(oprot)
5665 
    oprot.writeMessageEnd()
5666 
    oprot.trans.flush()
5667 
 
6039 amit.gupta 5668 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5669 
    args = getVatPercentageForItem_args()
5670 
    args.read(iprot)
5671 
    iprot.readMessageEnd()
5672 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5673 
    try:
5674 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5675 
    except CatalogServiceException, cex:
5676 
      result.cex = cex
6039 amit.gupta 5677 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5678 
    result.write(oprot)
5679 
    oprot.writeMessageEnd()
5680 
    oprot.trans.flush()
5944 mandeep.dh 5681 
 
6039 amit.gupta 5682 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5683 
    args = getVatAmountForItem_args()
5684 
    args.read(iprot)
5685 
    iprot.readMessageEnd()
5686 
    result = getVatAmountForItem_result()
5687 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5688 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5689 
    result.write(oprot)
5690 
    oprot.writeMessageEnd()
5691 
    oprot.trans.flush()
5692 
 
6531 vikram.rag 5693 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5694 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5695 
    args.read(iprot)
5696 
    iprot.readMessageEnd()
5697 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5698 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5699 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5700 
    result.write(oprot)
5701 
    oprot.writeMessageEnd()
5702 
    oprot.trans.flush()
6039 amit.gupta 5703 
 
6821 amar.kumar 5704 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5705 
    args = getAllAliveItems_args()
5706 
    args.read(iprot)
5707 
    iprot.readMessageEnd()
5708 
    result = getAllAliveItems_result()
5709 
    result.success = self._handler.getAllAliveItems()
5710 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5711 
    result.write(oprot)
5712 
    oprot.writeMessageEnd()
5713 
    oprot.trans.flush()
5714 
 
6805 anupam.sin 5715 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5716 
    args = getInsuranceAmount_args()
5717 
    args.read(iprot)
5718 
    iprot.readMessageEnd()
5719 
    result = getInsuranceAmount_result()
6921 anupam.sin 5720 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5721 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5722 
    result.write(oprot)
5723 
    oprot.writeMessageEnd()
5724 
    oprot.trans.flush()
6531 vikram.rag 5725 
 
6805 anupam.sin 5726 
  def process_getInsurer(self, seqid, iprot, oprot):
5727 
    args = getInsurer_args()
5728 
    args.read(iprot)
5729 
    iprot.readMessageEnd()
5730 
    result = getInsurer_result()
5731 
    result.success = self._handler.getInsurer(args.insurerId)
5732 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5733 
    result.write(oprot)
5734 
    oprot.writeMessageEnd()
5735 
    oprot.trans.flush()
5736 
 
6838 vikram.rag 5737 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5738 
    args = getAllInsurers_args()
5739 
    args.read(iprot)
5740 
    iprot.readMessageEnd()
5741 
    result = getAllInsurers_result()
5742 
    result.success = self._handler.getAllInsurers()
5743 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5744 
    result.write(oprot)
5745 
    oprot.writeMessageEnd()
5746 
    oprot.trans.flush()
6805 anupam.sin 5747 
 
6962 rajveer 5748 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5749 
    args = updateInsuranceDeclaredAmount_args()
5750 
    args.read(iprot)
5751 
    iprot.readMessageEnd()
5752 
    result = updateInsuranceDeclaredAmount_result()
5753 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5754 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5755 
    result.write(oprot)
5756 
    oprot.writeMessageEnd()
5757 
    oprot.trans.flush()
6838 vikram.rag 5758 
 
7190 amar.kumar 5759 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5760 
    args = getFreebieForItem_args()
5761 
    args.read(iprot)
5762 
    iprot.readMessageEnd()
5763 
    result = getFreebieForItem_result()
5764 
    result.success = self._handler.getFreebieForItem(args.itemId)
5765 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5766 
    result.write(oprot)
5767 
    oprot.writeMessageEnd()
5768 
    oprot.trans.flush()
6962 rajveer 5769 
 
7190 amar.kumar 5770 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5771 
    args = addOrUpdateFreebieForItem_args()
5772 
    args.read(iprot)
5773 
    iprot.readMessageEnd()
5774 
    result = addOrUpdateFreebieForItem_result()
5775 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5776 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5777 
    result.write(oprot)
5778 
    oprot.writeMessageEnd()
5779 
    oprot.trans.flush()
5780 
 
7272 amit.gupta 5781 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5782 
    args = addOrUpdateBrandInfo_args()
5783 
    args.read(iprot)
5784 
    iprot.readMessageEnd()
5785 
    result = addOrUpdateBrandInfo_result()
5786 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5787 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5788 
    result.write(oprot)
5789 
    oprot.writeMessageEnd()
5790 
    oprot.trans.flush()
5791 
 
5792 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5793 
    args = getBrandInfo_args()
5794 
    args.read(iprot)
5795 
    iprot.readMessageEnd()
5796 
    result = getBrandInfo_result()
5797 
    result.success = self._handler.getBrandInfo()
5798 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5799 
    result.write(oprot)
5800 
    oprot.writeMessageEnd()
5801 
    oprot.trans.flush()
5802 
 
7256 rajveer 5803 
  def process_getStorePricing(self, seqid, iprot, oprot):
5804 
    args = getStorePricing_args()
5805 
    args.read(iprot)
5806 
    iprot.readMessageEnd()
5807 
    result = getStorePricing_result()
5808 
    result.success = self._handler.getStorePricing(args.itemId)
5809 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5810 
    result.write(oprot)
5811 
    oprot.writeMessageEnd()
5812 
    oprot.trans.flush()
7190 amar.kumar 5813 
 
7306 rajveer 5814 
  def process_getStorePricings(self, seqid, iprot, oprot):
5815 
    args = getStorePricings_args()
5816 
    args.read(iprot)
5817 
    iprot.readMessageEnd()
5818 
    result = getStorePricings_result()
5819 
    result.success = self._handler.getStorePricings(args.itemIds)
5820 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5821 
    result.write(oprot)
5822 
    oprot.writeMessageEnd()
5823 
    oprot.trans.flush()
5824 
 
7265 rajveer 5825 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5826 
    args = updateStorePricing_args()
5827 
    args.read(iprot)
5828 
    iprot.readMessageEnd()
5829 
    result = updateStorePricing_result()
7382 rajveer 5830 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5831 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5832 
    result.write(oprot)
5833 
    oprot.writeMessageEnd()
5834 
    oprot.trans.flush()
7256 rajveer 5835 
 
7281 kshitij.so 5836 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5837 
    args = getAllAmazonListedItems_args()
5838 
    args.read(iprot)
5839 
    iprot.readMessageEnd()
5840 
    result = getAllAmazonListedItems_result()
5841 
    result.success = self._handler.getAllAmazonListedItems()
5842 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5843 
    result.write(oprot)
5844 
    oprot.writeMessageEnd()
5845 
    oprot.trans.flush()
7265 rajveer 5846 
 
7281 kshitij.so 5847 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5848 
    args = getAmazonItemDetails_args()
5849 
    args.read(iprot)
5850 
    iprot.readMessageEnd()
5851 
    result = getAmazonItemDetails_result()
5852 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5853 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5854 
    result.write(oprot)
5855 
    oprot.writeMessageEnd()
5856 
    oprot.trans.flush()
5857 
 
5858 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5859 
    args = updateAmazonItemDetails_args()
5860 
    args.read(iprot)
5861 
    iprot.readMessageEnd()
5862 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 5863 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 5864 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5865 
    result.write(oprot)
5866 
    oprot.writeMessageEnd()
5867 
    oprot.trans.flush()
5868 
 
5869 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5870 
    args = addAmazonItem_args()
5871 
    args.read(iprot)
5872 
    iprot.readMessageEnd()
5873 
    result = addAmazonItem_result()
5874 
    self._handler.addAmazonItem(args.amazonlisted)
5875 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5876 
    result.write(oprot)
5877 
    oprot.writeMessageEnd()
5878 
    oprot.trans.flush()
5879 
 
7291 vikram.rag 5880 
  def process_getAsinItems(self, seqid, iprot, oprot):
5881 
    args = getAsinItems_args()
5882 
    args.read(iprot)
5883 
    iprot.readMessageEnd()
5884 
    result = getAsinItems_result()
5885 
    result.success = self._handler.getAsinItems()
5886 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5887 
    result.write(oprot)
5888 
    oprot.writeMessageEnd()
5889 
    oprot.trans.flush()
7281 kshitij.so 5890 
 
7291 vikram.rag 5891 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5892 
    args = getAllFbaListedItems_args()
5893 
    args.read(iprot)
5894 
    iprot.readMessageEnd()
5895 
    result = getAllFbaListedItems_result()
5896 
    result.success = self._handler.getAllFbaListedItems()
5897 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5898 
    result.write(oprot)
5899 
    oprot.writeMessageEnd()
5900 
    oprot.trans.flush()
5901 
 
5902 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5903 
    args = getAllNonFbaListedItems_args()
5904 
    args.read(iprot)
5905 
    iprot.readMessageEnd()
5906 
    result = getAllNonFbaListedItems_result()
5907 
    result.success = self._handler.getAllNonFbaListedItems()
5908 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5909 
    result.write(oprot)
5910 
    oprot.writeMessageEnd()
5911 
    oprot.trans.flush()
5912 
 
7460 kshitij.so 5913 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5914 
    args = updateItemInventory_args()
5915 
    args.read(iprot)
5916 
    iprot.readMessageEnd()
5917 
    result = updateItemInventory_result()
5918 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5919 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5920 
    result.write(oprot)
5921 
    oprot.writeMessageEnd()
5922 
    oprot.trans.flush()
7291 vikram.rag 5923 
 
7770 kshitij.so 5924 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5925 
    args = updateTimestampForAmazonFeeds_args()
5926 
    args.read(iprot)
5927 
    iprot.readMessageEnd()
5928 
    result = updateTimestampForAmazonFeeds_result()
5929 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5930 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5931 
    result.write(oprot)
5932 
    oprot.writeMessageEnd()
5933 
    oprot.trans.flush()
7460 kshitij.so 5934 
 
7897 amar.kumar 5935 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5936 
    args = getAllParentCategories_args()
5937 
    args.read(iprot)
5938 
    iprot.readMessageEnd()
5939 
    result = getAllParentCategories_result()
5940 
    result.success = self._handler.getAllParentCategories()
5941 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5942 
    result.write(oprot)
5943 
    oprot.writeMessageEnd()
5944 
    oprot.trans.flush()
7770 kshitij.so 5945 
 
7977 kshitij.so 5946 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5947 
    args = addPageViewEvent_args()
5948 
    args.read(iprot)
5949 
    iprot.readMessageEnd()
5950 
    result = addPageViewEvent_result()
5951 
    self._handler.addPageViewEvent(args.pageViewEvents)
5952 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5953 
    result.write(oprot)
5954 
    oprot.writeMessageEnd()
5955 
    oprot.trans.flush()
7897 amar.kumar 5956 
 
7977 kshitij.so 5957 
  def process_addCartEvent(self, seqid, iprot, oprot):
5958 
    args = addCartEvent_args()
5959 
    args.read(iprot)
5960 
    iprot.readMessageEnd()
5961 
    result = addCartEvent_result()
5962 
    self._handler.addCartEvent(args.cartEvents)
5963 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5964 
    result.write(oprot)
5965 
    oprot.writeMessageEnd()
5966 
    oprot.trans.flush()
5967 
 
8182 amar.kumar 5968 
  def process_addEbayItem(self, seqid, iprot, oprot):
5969 
    args = addEbayItem_args()
5970 
    args.read(iprot)
5971 
    iprot.readMessageEnd()
5972 
    result = addEbayItem_result()
5973 
    self._handler.addEbayItem(args.ebayItem)
5974 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
5975 
    result.write(oprot)
5976 
    oprot.writeMessageEnd()
5977 
    oprot.trans.flush()
5978 
 
5979 
  def process_getEbayItem(self, seqid, iprot, oprot):
5980 
    args = getEbayItem_args()
5981 
    args.read(iprot)
5982 
    iprot.readMessageEnd()
5983 
    result = getEbayItem_result()
5984 
    result.success = self._handler.getEbayItem(args.listingId)
5985 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
5986 
    result.write(oprot)
5987 
    oprot.writeMessageEnd()
5988 
    oprot.trans.flush()
5989 
 
5990 
  def process_updateEbayItem(self, seqid, iprot, oprot):
5991 
    args = updateEbayItem_args()
5992 
    args.read(iprot)
5993 
    iprot.readMessageEnd()
5994 
    result = updateEbayItem_result()
5995 
    self._handler.updateEbayItem(args.ebayItem)
5996 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
5997 
    result.write(oprot)
5998 
    oprot.writeMessageEnd()
5999 
    oprot.trans.flush()
6000 
 
8139 kshitij.so 6001 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6002 
    args = getAmazonListedItems_args()
6003 
    args.read(iprot)
6004 
    iprot.readMessageEnd()
6005 
    result = getAmazonListedItems_result()
6006 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6007 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6008 
    result.write(oprot)
6009 
    oprot.writeMessageEnd()
6010 
    oprot.trans.flush()
7977 kshitij.so 6011 
 
8168 kshitij.so 6012 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6013 
    args = updateAmazonAttributesInBulk_args()
6014 
    args.read(iprot)
6015 
    iprot.readMessageEnd()
6016 
    result = updateAmazonAttributesInBulk_result()
6017 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6018 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6019 
    result.write(oprot)
6020 
    oprot.writeMessageEnd()
6021 
    oprot.trans.flush()
8139 kshitij.so 6022 
 
8379 vikram.rag 6023 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6024 
    args = getAllItemstoListOnFba_args()
6025 
    args.read(iprot)
6026 
    iprot.readMessageEnd()
6027 
    result = getAllItemstoListOnFba_result()
6028 
    result.success = self._handler.getAllItemstoListOnFba()
6029 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6030 
    result.write(oprot)
6031 
    oprot.writeMessageEnd()
6032 
    oprot.trans.flush()
8168 kshitij.so 6033 
 
8379 vikram.rag 6034 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6035 
    args = getAllItemstoListOnNonFba_args()
6036 
    args.read(iprot)
6037 
    iprot.readMessageEnd()
6038 
    result = getAllItemstoListOnNonFba_result()
6039 
    result.success = self._handler.getAllItemstoListOnNonFba()
6040 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6041 
    result.write(oprot)
6042 
    oprot.writeMessageEnd()
6043 
    oprot.trans.flush()
6044 
 
8616 vikram.rag 6045 
  def process_getAllSnapdealListedActiveItems(self, seqid, iprot, oprot):
6046 
    args = getAllSnapdealListedActiveItems_args()
6047 
    args.read(iprot)
6048 
    iprot.readMessageEnd()
6049 
    result = getAllSnapdealListedActiveItems_result()
6050 
    result.success = self._handler.getAllSnapdealListedActiveItems()
6051 
    oprot.writeMessageBegin("getAllSnapdealListedActiveItems", TMessageType.REPLY, seqid)
6052 
    result.write(oprot)
6053 
    oprot.writeMessageEnd()
6054 
    oprot.trans.flush()
8379 vikram.rag 6055 
 
8616 vikram.rag 6056 
 
5944 mandeep.dh 6057 
# HELPER FUNCTIONS AND STRUCTURES
6058 
 
6059 
class addItem_args:
6060 
  """
6061 
  Attributes:
6062 
   - item
6063 
  """
6064 
 
6065 
  thrift_spec = (
6066 
    None, # 0
6067 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6068 
  )
6069 
 
6070 
  def __init__(self, item=None,):
6071 
    self.item = item
6072 
 
6073 
  def read(self, iprot):
6074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6076 
      return
6077 
    iprot.readStructBegin()
6078 
    while True:
6079 
      (fname, ftype, fid) = iprot.readFieldBegin()
6080 
      if ftype == TType.STOP:
6081 
        break
6082 
      if fid == 1:
6083 
        if ftype == TType.STRUCT:
6084 
          self.item = Item()
6085 
          self.item.read(iprot)
6086 
        else:
6087 
          iprot.skip(ftype)
6088 
      else:
6089 
        iprot.skip(ftype)
6090 
      iprot.readFieldEnd()
6091 
    iprot.readStructEnd()
6092 
 
6093 
  def write(self, oprot):
6094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6096 
      return
6097 
    oprot.writeStructBegin('addItem_args')
6098 
    if self.item is not None:
6099 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6100 
      self.item.write(oprot)
6101 
      oprot.writeFieldEnd()
6102 
    oprot.writeFieldStop()
6103 
    oprot.writeStructEnd()
6104 
 
6105 
  def validate(self):
6106 
    return
6107 
 
6108 
 
6109 
  def __repr__(self):
6110 
    L = ['%s=%r' % (key, value)
6111 
      for key, value in self.__dict__.iteritems()]
6112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6113 
 
6114 
  def __eq__(self, other):
6115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6116 
 
6117 
  def __ne__(self, other):
6118 
    return not (self == other)
6119 
 
6120 
class addItem_result:
6121 
  """
6122 
  Attributes:
6123 
   - success
6124 
   - cex
6125 
  """
6126 
 
6127 
  thrift_spec = (
6128 
    (0, TType.I64, 'success', None, None, ), # 0
6129 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6130 
  )
6131 
 
6132 
  def __init__(self, success=None, cex=None,):
6133 
    self.success = success
6134 
    self.cex = cex
6135 
 
6136 
  def read(self, iprot):
6137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6139 
      return
6140 
    iprot.readStructBegin()
6141 
    while True:
6142 
      (fname, ftype, fid) = iprot.readFieldBegin()
6143 
      if ftype == TType.STOP:
6144 
        break
6145 
      if fid == 0:
6146 
        if ftype == TType.I64:
6147 
          self.success = iprot.readI64();
6148 
        else:
6149 
          iprot.skip(ftype)
6150 
      elif fid == 1:
6151 
        if ftype == TType.STRUCT:
6152 
          self.cex = CatalogServiceException()
6153 
          self.cex.read(iprot)
6154 
        else:
6155 
          iprot.skip(ftype)
6156 
      else:
6157 
        iprot.skip(ftype)
6158 
      iprot.readFieldEnd()
6159 
    iprot.readStructEnd()
6160 
 
6161 
  def write(self, oprot):
6162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6164 
      return
6165 
    oprot.writeStructBegin('addItem_result')
6166 
    if self.success is not None:
6167 
      oprot.writeFieldBegin('success', TType.I64, 0)
6168 
      oprot.writeI64(self.success)
6169 
      oprot.writeFieldEnd()
6170 
    if self.cex is not None:
6171 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6172 
      self.cex.write(oprot)
6173 
      oprot.writeFieldEnd()
6174 
    oprot.writeFieldStop()
6175 
    oprot.writeStructEnd()
6176 
 
6177 
  def validate(self):
6178 
    return
6179 
 
6180 
 
6181 
  def __repr__(self):
6182 
    L = ['%s=%r' % (key, value)
6183 
      for key, value in self.__dict__.iteritems()]
6184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6185 
 
6186 
  def __eq__(self, other):
6187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6188 
 
6189 
  def __ne__(self, other):
6190 
    return not (self == other)
6191 
 
6192 
class updateItem_args:
6193 
  """
6194 
  Attributes:
6195 
   - item
6196 
  """
6197 
 
6198 
  thrift_spec = (
6199 
    None, # 0
6200 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6201 
  )
6202 
 
6203 
  def __init__(self, item=None,):
6204 
    self.item = item
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 == 1:
6216 
        if ftype == TType.STRUCT:
6217 
          self.item = Item()
6218 
          self.item.read(iprot)
6219 
        else:
6220 
          iprot.skip(ftype)
6221 
      else:
6222 
        iprot.skip(ftype)
6223 
      iprot.readFieldEnd()
6224 
    iprot.readStructEnd()
6225 
 
6226 
  def write(self, oprot):
6227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6229 
      return
6230 
    oprot.writeStructBegin('updateItem_args')
6231 
    if self.item is not None:
6232 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6233 
      self.item.write(oprot)
6234 
      oprot.writeFieldEnd()
6235 
    oprot.writeFieldStop()
6236 
    oprot.writeStructEnd()
6237 
 
6238 
  def validate(self):
6239 
    return
6240 
 
6241 
 
6242 
  def __repr__(self):
6243 
    L = ['%s=%r' % (key, value)
6244 
      for key, value in self.__dict__.iteritems()]
6245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6246 
 
6247 
  def __eq__(self, other):
6248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6249 
 
6250 
  def __ne__(self, other):
6251 
    return not (self == other)
6252 
 
6253 
class updateItem_result:
6254 
  """
6255 
  Attributes:
6256 
   - success
6257 
   - cex
6258 
  """
6259 
 
6260 
  thrift_spec = (
6261 
    (0, TType.I64, 'success', None, None, ), # 0
6262 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6263 
  )
6264 
 
6265 
  def __init__(self, success=None, cex=None,):
6266 
    self.success = success
6267 
    self.cex = cex
6268 
 
6269 
  def read(self, iprot):
6270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6272 
      return
6273 
    iprot.readStructBegin()
6274 
    while True:
6275 
      (fname, ftype, fid) = iprot.readFieldBegin()
6276 
      if ftype == TType.STOP:
6277 
        break
6278 
      if fid == 0:
6279 
        if ftype == TType.I64:
6280 
          self.success = iprot.readI64();
6281 
        else:
6282 
          iprot.skip(ftype)
6283 
      elif fid == 1:
6284 
        if ftype == TType.STRUCT:
6285 
          self.cex = CatalogServiceException()
6286 
          self.cex.read(iprot)
6287 
        else:
6288 
          iprot.skip(ftype)
6289 
      else:
6290 
        iprot.skip(ftype)
6291 
      iprot.readFieldEnd()
6292 
    iprot.readStructEnd()
6293 
 
6294 
  def write(self, oprot):
6295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6297 
      return
6298 
    oprot.writeStructBegin('updateItem_result')
6299 
    if self.success is not None:
6300 
      oprot.writeFieldBegin('success', TType.I64, 0)
6301 
      oprot.writeI64(self.success)
6302 
      oprot.writeFieldEnd()
6303 
    if self.cex is not None:
6304 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6305 
      self.cex.write(oprot)
6306 
      oprot.writeFieldEnd()
6307 
    oprot.writeFieldStop()
6308 
    oprot.writeStructEnd()
6309 
 
6310 
  def validate(self):
6311 
    return
6312 
 
6313 
 
6314 
  def __repr__(self):
6315 
    L = ['%s=%r' % (key, value)
6316 
      for key, value in self.__dict__.iteritems()]
6317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6318 
 
6319 
  def __eq__(self, other):
6320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6321 
 
6322 
  def __ne__(self, other):
6323 
    return not (self == other)
6324 
 
6325 
class isActive_args:
6326 
  """
6327 
  Attributes:
6328 
   - itemId
6329 
  """
6330 
 
6331 
  thrift_spec = (
6332 
    None, # 0
6333 
    (1, TType.I64, 'itemId', None, None, ), # 1
6334 
  )
6335 
 
6336 
  def __init__(self, itemId=None,):
6337 
    self.itemId = itemId
6338 
 
6339 
  def read(self, iprot):
6340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6342 
      return
6343 
    iprot.readStructBegin()
6344 
    while True:
6345 
      (fname, ftype, fid) = iprot.readFieldBegin()
6346 
      if ftype == TType.STOP:
6347 
        break
6348 
      if fid == 1:
6349 
        if ftype == TType.I64:
6350 
          self.itemId = iprot.readI64();
6351 
        else:
6352 
          iprot.skip(ftype)
6353 
      else:
6354 
        iprot.skip(ftype)
6355 
      iprot.readFieldEnd()
6356 
    iprot.readStructEnd()
6357 
 
6358 
  def write(self, oprot):
6359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6361 
      return
6362 
    oprot.writeStructBegin('isActive_args')
6363 
    if self.itemId is not None:
6364 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6365 
      oprot.writeI64(self.itemId)
6366 
      oprot.writeFieldEnd()
6367 
    oprot.writeFieldStop()
6368 
    oprot.writeStructEnd()
6369 
 
6370 
  def validate(self):
6371 
    return
6372 
 
6373 
 
6374 
  def __repr__(self):
6375 
    L = ['%s=%r' % (key, value)
6376 
      for key, value in self.__dict__.iteritems()]
6377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6378 
 
6379 
  def __eq__(self, other):
6380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6381 
 
6382 
  def __ne__(self, other):
6383 
    return not (self == other)
6384 
 
6385 
class isActive_result:
6386 
  """
6387 
  Attributes:
6388 
   - success
6389 
   - isex
6390 
  """
6391 
 
6392 
  thrift_spec = (
6393 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6394 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6395 
  )
6396 
 
6397 
  def __init__(self, success=None, isex=None,):
6398 
    self.success = success
6399 
    self.isex = isex
6400 
 
6401 
  def read(self, iprot):
6402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6404 
      return
6405 
    iprot.readStructBegin()
6406 
    while True:
6407 
      (fname, ftype, fid) = iprot.readFieldBegin()
6408 
      if ftype == TType.STOP:
6409 
        break
6410 
      if fid == 0:
6411 
        if ftype == TType.STRUCT:
6412 
          self.success = ItemShippingInfo()
6413 
          self.success.read(iprot)
6414 
        else:
6415 
          iprot.skip(ftype)
6416 
      elif fid == 1:
6417 
        if ftype == TType.STRUCT:
6418 
          self.isex = CatalogServiceException()
6419 
          self.isex.read(iprot)
6420 
        else:
6421 
          iprot.skip(ftype)
6422 
      else:
6423 
        iprot.skip(ftype)
6424 
      iprot.readFieldEnd()
6425 
    iprot.readStructEnd()
6426 
 
6427 
  def write(self, oprot):
6428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6430 
      return
6431 
    oprot.writeStructBegin('isActive_result')
6432 
    if self.success is not None:
6433 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6434 
      self.success.write(oprot)
6435 
      oprot.writeFieldEnd()
6436 
    if self.isex is not None:
6437 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6438 
      self.isex.write(oprot)
6439 
      oprot.writeFieldEnd()
6440 
    oprot.writeFieldStop()
6441 
    oprot.writeStructEnd()
6442 
 
6443 
  def validate(self):
6444 
    return
6445 
 
6446 
 
6447 
  def __repr__(self):
6448 
    L = ['%s=%r' % (key, value)
6449 
      for key, value in self.__dict__.iteritems()]
6450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6451 
 
6452 
  def __eq__(self, other):
6453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6454 
 
6455 
  def __ne__(self, other):
6456 
    return not (self == other)
6457 
 
7438 amit.gupta 6458 
class getItemsStatus_args:
6459 
  """
6460 
  Attributes:
6461 
   - itemIds
6462 
  """
6463 
 
6464 
  thrift_spec = (
6465 
    None, # 0
6466 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6467 
  )
6468 
 
6469 
  def __init__(self, itemIds=None,):
6470 
    self.itemIds = itemIds
6471 
 
6472 
  def read(self, iprot):
6473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6475 
      return
6476 
    iprot.readStructBegin()
6477 
    while True:
6478 
      (fname, ftype, fid) = iprot.readFieldBegin()
6479 
      if ftype == TType.STOP:
6480 
        break
6481 
      if fid == 1:
6482 
        if ftype == TType.LIST:
6483 
          self.itemIds = []
8590 kshitij.so 6484 
          (_etype33, _size30) = iprot.readListBegin()
6485 
          for _i34 in xrange(_size30):
6486 
            _elem35 = iprot.readI64();
6487 
            self.itemIds.append(_elem35)
7438 amit.gupta 6488 
          iprot.readListEnd()
6489 
        else:
6490 
          iprot.skip(ftype)
6491 
      else:
6492 
        iprot.skip(ftype)
6493 
      iprot.readFieldEnd()
6494 
    iprot.readStructEnd()
6495 
 
6496 
  def write(self, oprot):
6497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6499 
      return
6500 
    oprot.writeStructBegin('getItemsStatus_args')
6501 
    if self.itemIds is not None:
6502 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6503 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 6504 
      for iter36 in self.itemIds:
6505 
        oprot.writeI64(iter36)
7438 amit.gupta 6506 
      oprot.writeListEnd()
6507 
      oprot.writeFieldEnd()
6508 
    oprot.writeFieldStop()
6509 
    oprot.writeStructEnd()
6510 
 
6511 
  def validate(self):
6512 
    return
6513 
 
6514 
 
6515 
  def __repr__(self):
6516 
    L = ['%s=%r' % (key, value)
6517 
      for key, value in self.__dict__.iteritems()]
6518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6519 
 
6520 
  def __eq__(self, other):
6521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6522 
 
6523 
  def __ne__(self, other):
6524 
    return not (self == other)
6525 
 
6526 
class getItemsStatus_result:
6527 
  """
6528 
  Attributes:
6529 
   - success
6530 
   - isex
6531 
  """
6532 
 
6533 
  thrift_spec = (
6534 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6535 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6536 
  )
6537 
 
6538 
  def __init__(self, success=None, isex=None,):
6539 
    self.success = success
6540 
    self.isex = isex
6541 
 
6542 
  def read(self, iprot):
6543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6545 
      return
6546 
    iprot.readStructBegin()
6547 
    while True:
6548 
      (fname, ftype, fid) = iprot.readFieldBegin()
6549 
      if ftype == TType.STOP:
6550 
        break
6551 
      if fid == 0:
6552 
        if ftype == TType.MAP:
6553 
          self.success = {}
8590 kshitij.so 6554 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
6555 
          for _i41 in xrange(_size37):
6556 
            _key42 = iprot.readI64();
6557 
            _val43 = iprot.readBool();
6558 
            self.success[_key42] = _val43
7438 amit.gupta 6559 
          iprot.readMapEnd()
6560 
        else:
6561 
          iprot.skip(ftype)
6562 
      elif fid == 1:
6563 
        if ftype == TType.STRUCT:
6564 
          self.isex = CatalogServiceException()
6565 
          self.isex.read(iprot)
6566 
        else:
6567 
          iprot.skip(ftype)
6568 
      else:
6569 
        iprot.skip(ftype)
6570 
      iprot.readFieldEnd()
6571 
    iprot.readStructEnd()
6572 
 
6573 
  def write(self, oprot):
6574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6576 
      return
6577 
    oprot.writeStructBegin('getItemsStatus_result')
6578 
    if self.success is not None:
6579 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6580 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 6581 
      for kiter44,viter45 in self.success.items():
6582 
        oprot.writeI64(kiter44)
6583 
        oprot.writeBool(viter45)
7438 amit.gupta 6584 
      oprot.writeMapEnd()
6585 
      oprot.writeFieldEnd()
6586 
    if self.isex is not None:
6587 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6588 
      self.isex.write(oprot)
6589 
      oprot.writeFieldEnd()
6590 
    oprot.writeFieldStop()
6591 
    oprot.writeStructEnd()
6592 
 
6593 
  def validate(self):
6594 
    return
6595 
 
6596 
 
6597 
  def __repr__(self):
6598 
    L = ['%s=%r' % (key, value)
6599 
      for key, value in self.__dict__.iteritems()]
6600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6601 
 
6602 
  def __eq__(self, other):
6603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6604 
 
6605 
  def __ne__(self, other):
6606 
    return not (self == other)
6607 
 
5944 mandeep.dh 6608 
class getItemStatusDescription_args:
6609 
  """
6610 
  Attributes:
6611 
   - itemId
6612 
  """
6613 
 
6614 
  thrift_spec = (
6615 
    None, # 0
6616 
    (1, TType.I64, 'itemId', None, None, ), # 1
6617 
  )
6618 
 
6619 
  def __init__(self, itemId=None,):
6620 
    self.itemId = itemId
6621 
 
6622 
  def read(self, iprot):
6623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6625 
      return
6626 
    iprot.readStructBegin()
6627 
    while True:
6628 
      (fname, ftype, fid) = iprot.readFieldBegin()
6629 
      if ftype == TType.STOP:
6630 
        break
6631 
      if fid == 1:
6632 
        if ftype == TType.I64:
6633 
          self.itemId = iprot.readI64();
6634 
        else:
6635 
          iprot.skip(ftype)
6636 
      else:
6637 
        iprot.skip(ftype)
6638 
      iprot.readFieldEnd()
6639 
    iprot.readStructEnd()
6640 
 
6641 
  def write(self, oprot):
6642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6644 
      return
6645 
    oprot.writeStructBegin('getItemStatusDescription_args')
6646 
    if self.itemId is not None:
6647 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6648 
      oprot.writeI64(self.itemId)
6649 
      oprot.writeFieldEnd()
6650 
    oprot.writeFieldStop()
6651 
    oprot.writeStructEnd()
6652 
 
6653 
  def validate(self):
6654 
    return
6655 
 
6656 
 
6657 
  def __repr__(self):
6658 
    L = ['%s=%r' % (key, value)
6659 
      for key, value in self.__dict__.iteritems()]
6660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6661 
 
6662 
  def __eq__(self, other):
6663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6664 
 
6665 
  def __ne__(self, other):
6666 
    return not (self == other)
6667 
 
6668 
class getItemStatusDescription_result:
6669 
  """
6670 
  Attributes:
6671 
   - success
6672 
   - isex
6673 
  """
6674 
 
6675 
  thrift_spec = (
6676 
    (0, TType.STRING, 'success', None, None, ), # 0
6677 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6678 
  )
6679 
 
6680 
  def __init__(self, success=None, isex=None,):
6681 
    self.success = success
6682 
    self.isex = isex
6683 
 
6684 
  def read(self, iprot):
6685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6687 
      return
6688 
    iprot.readStructBegin()
6689 
    while True:
6690 
      (fname, ftype, fid) = iprot.readFieldBegin()
6691 
      if ftype == TType.STOP:
6692 
        break
6693 
      if fid == 0:
6694 
        if ftype == TType.STRING:
6695 
          self.success = iprot.readString();
6696 
        else:
6697 
          iprot.skip(ftype)
6698 
      elif fid == 1:
6699 
        if ftype == TType.STRUCT:
6700 
          self.isex = CatalogServiceException()
6701 
          self.isex.read(iprot)
6702 
        else:
6703 
          iprot.skip(ftype)
6704 
      else:
6705 
        iprot.skip(ftype)
6706 
      iprot.readFieldEnd()
6707 
    iprot.readStructEnd()
6708 
 
6709 
  def write(self, oprot):
6710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6712 
      return
6713 
    oprot.writeStructBegin('getItemStatusDescription_result')
6714 
    if self.success is not None:
6715 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6716 
      oprot.writeString(self.success)
6717 
      oprot.writeFieldEnd()
6718 
    if self.isex is not None:
6719 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6720 
      self.isex.write(oprot)
6721 
      oprot.writeFieldEnd()
6722 
    oprot.writeFieldStop()
6723 
    oprot.writeStructEnd()
6724 
 
6725 
  def validate(self):
6726 
    return
6727 
 
6728 
 
6729 
  def __repr__(self):
6730 
    L = ['%s=%r' % (key, value)
6731 
      for key, value in self.__dict__.iteritems()]
6732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6733 
 
6734 
  def __eq__(self, other):
6735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6736 
 
6737 
  def __ne__(self, other):
6738 
    return not (self == other)
6739 
 
6740 
class startItemOn_args:
6741 
  """
6742 
  Attributes:
6743 
   - item_id
6744 
   - timestamp
6745 
  """
6746 
 
6747 
  thrift_spec = (
6748 
    None, # 0
6749 
    (1, TType.I64, 'item_id', None, None, ), # 1
6750 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6751 
  )
6752 
 
6753 
  def __init__(self, item_id=None, timestamp=None,):
6754 
    self.item_id = item_id
6755 
    self.timestamp = timestamp
6756 
 
6757 
  def read(self, iprot):
6758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6760 
      return
6761 
    iprot.readStructBegin()
6762 
    while True:
6763 
      (fname, ftype, fid) = iprot.readFieldBegin()
6764 
      if ftype == TType.STOP:
6765 
        break
6766 
      if fid == 1:
6767 
        if ftype == TType.I64:
6768 
          self.item_id = iprot.readI64();
6769 
        else:
6770 
          iprot.skip(ftype)
6771 
      elif fid == 2:
6772 
        if ftype == TType.I64:
6773 
          self.timestamp = iprot.readI64();
6774 
        else:
6775 
          iprot.skip(ftype)
6776 
      else:
6777 
        iprot.skip(ftype)
6778 
      iprot.readFieldEnd()
6779 
    iprot.readStructEnd()
6780 
 
6781 
  def write(self, oprot):
6782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6784 
      return
6785 
    oprot.writeStructBegin('startItemOn_args')
6786 
    if self.item_id is not None:
6787 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6788 
      oprot.writeI64(self.item_id)
6789 
      oprot.writeFieldEnd()
6790 
    if self.timestamp is not None:
6791 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6792 
      oprot.writeI64(self.timestamp)
6793 
      oprot.writeFieldEnd()
6794 
    oprot.writeFieldStop()
6795 
    oprot.writeStructEnd()
6796 
 
6797 
  def validate(self):
6798 
    return
6799 
 
6800 
 
6801 
  def __repr__(self):
6802 
    L = ['%s=%r' % (key, value)
6803 
      for key, value in self.__dict__.iteritems()]
6804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6805 
 
6806 
  def __eq__(self, other):
6807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6808 
 
6809 
  def __ne__(self, other):
6810 
    return not (self == other)
6811 
 
6812 
class startItemOn_result:
6813 
  """
6814 
  Attributes:
6815 
   - cex
6816 
  """
6817 
 
6818 
  thrift_spec = (
6819 
    None, # 0
6820 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6821 
  )
6822 
 
6823 
  def __init__(self, cex=None,):
6824 
    self.cex = cex
6825 
 
6826 
  def read(self, iprot):
6827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6829 
      return
6830 
    iprot.readStructBegin()
6831 
    while True:
6832 
      (fname, ftype, fid) = iprot.readFieldBegin()
6833 
      if ftype == TType.STOP:
6834 
        break
6835 
      if fid == 1:
6836 
        if ftype == TType.STRUCT:
6837 
          self.cex = CatalogServiceException()
6838 
          self.cex.read(iprot)
6839 
        else:
6840 
          iprot.skip(ftype)
6841 
      else:
6842 
        iprot.skip(ftype)
6843 
      iprot.readFieldEnd()
6844 
    iprot.readStructEnd()
6845 
 
6846 
  def write(self, oprot):
6847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6849 
      return
6850 
    oprot.writeStructBegin('startItemOn_result')
6851 
    if self.cex is not None:
6852 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6853 
      self.cex.write(oprot)
6854 
      oprot.writeFieldEnd()
6855 
    oprot.writeFieldStop()
6856 
    oprot.writeStructEnd()
6857 
 
6858 
  def validate(self):
6859 
    return
6860 
 
6861 
 
6862 
  def __repr__(self):
6863 
    L = ['%s=%r' % (key, value)
6864 
      for key, value in self.__dict__.iteritems()]
6865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6866 
 
6867 
  def __eq__(self, other):
6868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6869 
 
6870 
  def __ne__(self, other):
6871 
    return not (self == other)
6872 
 
6873 
class retireItemOn_args:
6874 
  """
6875 
  Attributes:
6876 
   - item_id
6877 
   - timestamp
6878 
  """
6879 
 
6880 
  thrift_spec = (
6881 
    None, # 0
6882 
    (1, TType.I64, 'item_id', None, None, ), # 1
6883 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6884 
  )
6885 
 
6886 
  def __init__(self, item_id=None, timestamp=None,):
6887 
    self.item_id = item_id
6888 
    self.timestamp = timestamp
6889 
 
6890 
  def read(self, iprot):
6891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6893 
      return
6894 
    iprot.readStructBegin()
6895 
    while True:
6896 
      (fname, ftype, fid) = iprot.readFieldBegin()
6897 
      if ftype == TType.STOP:
6898 
        break
6899 
      if fid == 1:
6900 
        if ftype == TType.I64:
6901 
          self.item_id = iprot.readI64();
6902 
        else:
6903 
          iprot.skip(ftype)
6904 
      elif fid == 2:
6905 
        if ftype == TType.I64:
6906 
          self.timestamp = iprot.readI64();
6907 
        else:
6908 
          iprot.skip(ftype)
6909 
      else:
6910 
        iprot.skip(ftype)
6911 
      iprot.readFieldEnd()
6912 
    iprot.readStructEnd()
6913 
 
6914 
  def write(self, oprot):
6915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6917 
      return
6918 
    oprot.writeStructBegin('retireItemOn_args')
6919 
    if self.item_id is not None:
6920 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6921 
      oprot.writeI64(self.item_id)
6922 
      oprot.writeFieldEnd()
6923 
    if self.timestamp is not None:
6924 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6925 
      oprot.writeI64(self.timestamp)
6926 
      oprot.writeFieldEnd()
6927 
    oprot.writeFieldStop()
6928 
    oprot.writeStructEnd()
6929 
 
6930 
  def validate(self):
6931 
    return
6932 
 
6933 
 
6934 
  def __repr__(self):
6935 
    L = ['%s=%r' % (key, value)
6936 
      for key, value in self.__dict__.iteritems()]
6937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6938 
 
6939 
  def __eq__(self, other):
6940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6941 
 
6942 
  def __ne__(self, other):
6943 
    return not (self == other)
6944 
 
6945 
class retireItemOn_result:
6946 
  """
6947 
  Attributes:
6948 
   - cex
6949 
  """
6950 
 
6951 
  thrift_spec = (
6952 
    None, # 0
6953 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6954 
  )
6955 
 
6956 
  def __init__(self, cex=None,):
6957 
    self.cex = cex
6958 
 
6959 
  def read(self, iprot):
6960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6962 
      return
6963 
    iprot.readStructBegin()
6964 
    while True:
6965 
      (fname, ftype, fid) = iprot.readFieldBegin()
6966 
      if ftype == TType.STOP:
6967 
        break
6968 
      if fid == 1:
6969 
        if ftype == TType.STRUCT:
6970 
          self.cex = CatalogServiceException()
6971 
          self.cex.read(iprot)
6972 
        else:
6973 
          iprot.skip(ftype)
6974 
      else:
6975 
        iprot.skip(ftype)
6976 
      iprot.readFieldEnd()
6977 
    iprot.readStructEnd()
6978 
 
6979 
  def write(self, oprot):
6980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6982 
      return
6983 
    oprot.writeStructBegin('retireItemOn_result')
6984 
    if self.cex is not None:
6985 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6986 
      self.cex.write(oprot)
6987 
      oprot.writeFieldEnd()
6988 
    oprot.writeFieldStop()
6989 
    oprot.writeStructEnd()
6990 
 
6991 
  def validate(self):
6992 
    return
6993 
 
6994 
 
6995 
  def __repr__(self):
6996 
    L = ['%s=%r' % (key, value)
6997 
      for key, value in self.__dict__.iteritems()]
6998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6999 
 
7000 
  def __eq__(self, other):
7001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7002 
 
7003 
  def __ne__(self, other):
7004 
    return not (self == other)
7005 
 
7006 
class changeItemStatus_args:
7007 
  """
7008 
  Attributes:
7009 
   - item_id
7010 
   - timestamp
7011 
   - newstatus
7012 
  """
7013 
 
7014 
  thrift_spec = (
7015 
    None, # 0
7016 
    (1, TType.I64, 'item_id', None, None, ), # 1
7017 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7018 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7019 
  )
7020 
 
7021 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7022 
    self.item_id = item_id
7023 
    self.timestamp = timestamp
7024 
    self.newstatus = newstatus
7025 
 
7026 
  def read(self, iprot):
7027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7029 
      return
7030 
    iprot.readStructBegin()
7031 
    while True:
7032 
      (fname, ftype, fid) = iprot.readFieldBegin()
7033 
      if ftype == TType.STOP:
7034 
        break
7035 
      if fid == 1:
7036 
        if ftype == TType.I64:
7037 
          self.item_id = iprot.readI64();
7038 
        else:
7039 
          iprot.skip(ftype)
7040 
      elif fid == 2:
7041 
        if ftype == TType.I64:
7042 
          self.timestamp = iprot.readI64();
7043 
        else:
7044 
          iprot.skip(ftype)
7045 
      elif fid == 3:
7046 
        if ftype == TType.I32:
7047 
          self.newstatus = iprot.readI32();
7048 
        else:
7049 
          iprot.skip(ftype)
7050 
      else:
7051 
        iprot.skip(ftype)
7052 
      iprot.readFieldEnd()
7053 
    iprot.readStructEnd()
7054 
 
7055 
  def write(self, oprot):
7056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7058 
      return
7059 
    oprot.writeStructBegin('changeItemStatus_args')
7060 
    if self.item_id is not None:
7061 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7062 
      oprot.writeI64(self.item_id)
7063 
      oprot.writeFieldEnd()
7064 
    if self.timestamp is not None:
7065 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7066 
      oprot.writeI64(self.timestamp)
7067 
      oprot.writeFieldEnd()
7068 
    if self.newstatus is not None:
7069 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7070 
      oprot.writeI32(self.newstatus)
7071 
      oprot.writeFieldEnd()
7072 
    oprot.writeFieldStop()
7073 
    oprot.writeStructEnd()
7074 
 
7075 
  def validate(self):
7076 
    return
7077 
 
7078 
 
7079 
  def __repr__(self):
7080 
    L = ['%s=%r' % (key, value)
7081 
      for key, value in self.__dict__.iteritems()]
7082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7083 
 
7084 
  def __eq__(self, other):
7085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7086 
 
7087 
  def __ne__(self, other):
7088 
    return not (self == other)
7089 
 
7090 
class changeItemStatus_result:
7091 
  """
7092 
  Attributes:
7093 
   - cex
7094 
  """
7095 
 
7096 
  thrift_spec = (
7097 
    None, # 0
7098 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7099 
  )
7100 
 
7101 
  def __init__(self, cex=None,):
7102 
    self.cex = cex
7103 
 
7104 
  def read(self, iprot):
7105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7107 
      return
7108 
    iprot.readStructBegin()
7109 
    while True:
7110 
      (fname, ftype, fid) = iprot.readFieldBegin()
7111 
      if ftype == TType.STOP:
7112 
        break
7113 
      if fid == 1:
7114 
        if ftype == TType.STRUCT:
7115 
          self.cex = CatalogServiceException()
7116 
          self.cex.read(iprot)
7117 
        else:
7118 
          iprot.skip(ftype)
7119 
      else:
7120 
        iprot.skip(ftype)
7121 
      iprot.readFieldEnd()
7122 
    iprot.readStructEnd()
7123 
 
7124 
  def write(self, oprot):
7125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7127 
      return
7128 
    oprot.writeStructBegin('changeItemStatus_result')
7129 
    if self.cex is not None:
7130 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7131 
      self.cex.write(oprot)
7132 
      oprot.writeFieldEnd()
7133 
    oprot.writeFieldStop()
7134 
    oprot.writeStructEnd()
7135 
 
7136 
  def validate(self):
7137 
    return
7138 
 
7139 
 
7140 
  def __repr__(self):
7141 
    L = ['%s=%r' % (key, value)
7142 
      for key, value in self.__dict__.iteritems()]
7143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7144 
 
7145 
  def __eq__(self, other):
7146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7147 
 
7148 
  def __ne__(self, other):
7149 
    return not (self == other)
7150 
 
7151 
class getItem_args:
7152 
  """
7153 
  Attributes:
7154 
   - item_id
7155 
  """
7156 
 
7157 
  thrift_spec = (
7158 
    None, # 0
7159 
    (1, TType.I64, 'item_id', None, None, ), # 1
7160 
  )
7161 
 
7162 
  def __init__(self, item_id=None,):
7163 
    self.item_id = item_id
7164 
 
7165 
  def read(self, iprot):
7166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7168 
      return
7169 
    iprot.readStructBegin()
7170 
    while True:
7171 
      (fname, ftype, fid) = iprot.readFieldBegin()
7172 
      if ftype == TType.STOP:
7173 
        break
7174 
      if fid == 1:
7175 
        if ftype == TType.I64:
7176 
          self.item_id = iprot.readI64();
7177 
        else:
7178 
          iprot.skip(ftype)
7179 
      else:
7180 
        iprot.skip(ftype)
7181 
      iprot.readFieldEnd()
7182 
    iprot.readStructEnd()
7183 
 
7184 
  def write(self, oprot):
7185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7187 
      return
7188 
    oprot.writeStructBegin('getItem_args')
7189 
    if self.item_id is not None:
7190 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7191 
      oprot.writeI64(self.item_id)
7192 
      oprot.writeFieldEnd()
7193 
    oprot.writeFieldStop()
7194 
    oprot.writeStructEnd()
7195 
 
7196 
  def validate(self):
7197 
    return
7198 
 
7199 
 
7200 
  def __repr__(self):
7201 
    L = ['%s=%r' % (key, value)
7202 
      for key, value in self.__dict__.iteritems()]
7203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7204 
 
7205 
  def __eq__(self, other):
7206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7207 
 
7208 
  def __ne__(self, other):
7209 
    return not (self == other)
7210 
 
7211 
class getItem_result:
7212 
  """
7213 
  Attributes:
7214 
   - success
7215 
   - cex
7216 
  """
7217 
 
7218 
  thrift_spec = (
7219 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7220 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7221 
  )
7222 
 
7223 
  def __init__(self, success=None, cex=None,):
7224 
    self.success = success
7225 
    self.cex = cex
7226 
 
7227 
  def read(self, iprot):
7228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7230 
      return
7231 
    iprot.readStructBegin()
7232 
    while True:
7233 
      (fname, ftype, fid) = iprot.readFieldBegin()
7234 
      if ftype == TType.STOP:
7235 
        break
7236 
      if fid == 0:
7237 
        if ftype == TType.STRUCT:
7238 
          self.success = Item()
7239 
          self.success.read(iprot)
7240 
        else:
7241 
          iprot.skip(ftype)
7242 
      elif fid == 1:
7243 
        if ftype == TType.STRUCT:
7244 
          self.cex = CatalogServiceException()
7245 
          self.cex.read(iprot)
7246 
        else:
7247 
          iprot.skip(ftype)
7248 
      else:
7249 
        iprot.skip(ftype)
7250 
      iprot.readFieldEnd()
7251 
    iprot.readStructEnd()
7252 
 
7253 
  def write(self, oprot):
7254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7256 
      return
7257 
    oprot.writeStructBegin('getItem_result')
7258 
    if self.success is not None:
7259 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7260 
      self.success.write(oprot)
7261 
      oprot.writeFieldEnd()
7262 
    if self.cex is not None:
7263 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7264 
      self.cex.write(oprot)
7265 
      oprot.writeFieldEnd()
7266 
    oprot.writeFieldStop()
7267 
    oprot.writeStructEnd()
7268 
 
7269 
  def validate(self):
7270 
    return
7271 
 
7272 
 
7273 
  def __repr__(self):
7274 
    L = ['%s=%r' % (key, value)
7275 
      for key, value in self.__dict__.iteritems()]
7276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7277 
 
7278 
  def __eq__(self, other):
7279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7280 
 
7281 
  def __ne__(self, other):
7282 
    return not (self == other)
7283 
 
7284 
class getItemsByCatalogId_args:
7285 
  """
7286 
  Attributes:
7287 
   - catalog_item_id
7288 
  """
7289 
 
7290 
  thrift_spec = (
7291 
    None, # 0
7292 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7293 
  )
7294 
 
7295 
  def __init__(self, catalog_item_id=None,):
7296 
    self.catalog_item_id = catalog_item_id
7297 
 
7298 
  def read(self, iprot):
7299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7301 
      return
7302 
    iprot.readStructBegin()
7303 
    while True:
7304 
      (fname, ftype, fid) = iprot.readFieldBegin()
7305 
      if ftype == TType.STOP:
7306 
        break
7307 
      if fid == 1:
7308 
        if ftype == TType.I64:
7309 
          self.catalog_item_id = iprot.readI64();
7310 
        else:
7311 
          iprot.skip(ftype)
7312 
      else:
7313 
        iprot.skip(ftype)
7314 
      iprot.readFieldEnd()
7315 
    iprot.readStructEnd()
7316 
 
7317 
  def write(self, oprot):
7318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7320 
      return
7321 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7322 
    if self.catalog_item_id is not None:
7323 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7324 
      oprot.writeI64(self.catalog_item_id)
7325 
      oprot.writeFieldEnd()
7326 
    oprot.writeFieldStop()
7327 
    oprot.writeStructEnd()
7328 
 
7329 
  def validate(self):
7330 
    return
7331 
 
7332 
 
7333 
  def __repr__(self):
7334 
    L = ['%s=%r' % (key, value)
7335 
      for key, value in self.__dict__.iteritems()]
7336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7337 
 
7338 
  def __eq__(self, other):
7339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7340 
 
7341 
  def __ne__(self, other):
7342 
    return not (self == other)
7343 
 
7344 
class getItemsByCatalogId_result:
7345 
  """
7346 
  Attributes:
7347 
   - success
7348 
   - cex
7349 
  """
7350 
 
7351 
  thrift_spec = (
7352 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7353 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7354 
  )
7355 
 
7356 
  def __init__(self, success=None, cex=None,):
7357 
    self.success = success
7358 
    self.cex = cex
7359 
 
7360 
  def read(self, iprot):
7361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7363 
      return
7364 
    iprot.readStructBegin()
7365 
    while True:
7366 
      (fname, ftype, fid) = iprot.readFieldBegin()
7367 
      if ftype == TType.STOP:
7368 
        break
7369 
      if fid == 0:
7370 
        if ftype == TType.LIST:
7371 
          self.success = []
8590 kshitij.so 7372 
          (_etype49, _size46) = iprot.readListBegin()
7373 
          for _i50 in xrange(_size46):
7374 
            _elem51 = Item()
7375 
            _elem51.read(iprot)
7376 
            self.success.append(_elem51)
5944 mandeep.dh 7377 
          iprot.readListEnd()
7378 
        else:
7379 
          iprot.skip(ftype)
7380 
      elif fid == 1:
7381 
        if ftype == TType.STRUCT:
7382 
          self.cex = CatalogServiceException()
7383 
          self.cex.read(iprot)
7384 
        else:
7385 
          iprot.skip(ftype)
7386 
      else:
7387 
        iprot.skip(ftype)
7388 
      iprot.readFieldEnd()
7389 
    iprot.readStructEnd()
7390 
 
7391 
  def write(self, oprot):
7392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7394 
      return
7395 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7396 
    if self.success is not None:
7397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7399 
      for iter52 in self.success:
7400 
        iter52.write(oprot)
5944 mandeep.dh 7401 
      oprot.writeListEnd()
7402 
      oprot.writeFieldEnd()
7403 
    if self.cex is not None:
7404 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7405 
      self.cex.write(oprot)
7406 
      oprot.writeFieldEnd()
7407 
    oprot.writeFieldStop()
7408 
    oprot.writeStructEnd()
7409 
 
7410 
  def validate(self):
7411 
    return
7412 
 
7413 
 
7414 
  def __repr__(self):
7415 
    L = ['%s=%r' % (key, value)
7416 
      for key, value in self.__dict__.iteritems()]
7417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7418 
 
7419 
  def __eq__(self, other):
7420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7421 
 
7422 
  def __ne__(self, other):
7423 
    return not (self == other)
7424 
 
7425 
class getValidItemsByCatalogId_args:
7426 
  """
7427 
  Attributes:
7428 
   - catalog_item_id
7429 
  """
7430 
 
7431 
  thrift_spec = (
7432 
    None, # 0
7433 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7434 
  )
7435 
 
7436 
  def __init__(self, catalog_item_id=None,):
7437 
    self.catalog_item_id = catalog_item_id
7438 
 
7439 
  def read(self, iprot):
7440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7442 
      return
7443 
    iprot.readStructBegin()
7444 
    while True:
7445 
      (fname, ftype, fid) = iprot.readFieldBegin()
7446 
      if ftype == TType.STOP:
7447 
        break
7448 
      if fid == 1:
7449 
        if ftype == TType.I64:
7450 
          self.catalog_item_id = iprot.readI64();
7451 
        else:
7452 
          iprot.skip(ftype)
7453 
      else:
7454 
        iprot.skip(ftype)
7455 
      iprot.readFieldEnd()
7456 
    iprot.readStructEnd()
7457 
 
7458 
  def write(self, oprot):
7459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7461 
      return
7462 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7463 
    if self.catalog_item_id is not None:
7464 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7465 
      oprot.writeI64(self.catalog_item_id)
7466 
      oprot.writeFieldEnd()
7467 
    oprot.writeFieldStop()
7468 
    oprot.writeStructEnd()
7469 
 
7470 
  def validate(self):
7471 
    return
7472 
 
7473 
 
7474 
  def __repr__(self):
7475 
    L = ['%s=%r' % (key, value)
7476 
      for key, value in self.__dict__.iteritems()]
7477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7478 
 
7479 
  def __eq__(self, other):
7480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7481 
 
7482 
  def __ne__(self, other):
7483 
    return not (self == other)
7484 
 
7485 
class getValidItemsByCatalogId_result:
7486 
  """
7487 
  Attributes:
7488 
   - success
7489 
   - cex
7490 
  """
7491 
 
7492 
  thrift_spec = (
7493 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7494 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7495 
  )
7496 
 
7497 
  def __init__(self, success=None, cex=None,):
7498 
    self.success = success
7499 
    self.cex = cex
7500 
 
7501 
  def read(self, iprot):
7502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7504 
      return
7505 
    iprot.readStructBegin()
7506 
    while True:
7507 
      (fname, ftype, fid) = iprot.readFieldBegin()
7508 
      if ftype == TType.STOP:
7509 
        break
7510 
      if fid == 0:
7511 
        if ftype == TType.LIST:
7512 
          self.success = []
8590 kshitij.so 7513 
          (_etype56, _size53) = iprot.readListBegin()
7514 
          for _i57 in xrange(_size53):
7515 
            _elem58 = Item()
7516 
            _elem58.read(iprot)
7517 
            self.success.append(_elem58)
5944 mandeep.dh 7518 
          iprot.readListEnd()
7519 
        else:
7520 
          iprot.skip(ftype)
7521 
      elif fid == 1:
7522 
        if ftype == TType.STRUCT:
7523 
          self.cex = CatalogServiceException()
7524 
          self.cex.read(iprot)
7525 
        else:
7526 
          iprot.skip(ftype)
7527 
      else:
7528 
        iprot.skip(ftype)
7529 
      iprot.readFieldEnd()
7530 
    iprot.readStructEnd()
7531 
 
7532 
  def write(self, oprot):
7533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7535 
      return
7536 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7537 
    if self.success is not None:
7538 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7539 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7540 
      for iter59 in self.success:
7541 
        iter59.write(oprot)
5944 mandeep.dh 7542 
      oprot.writeListEnd()
7543 
      oprot.writeFieldEnd()
7544 
    if self.cex is not None:
7545 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7546 
      self.cex.write(oprot)
7547 
      oprot.writeFieldEnd()
7548 
    oprot.writeFieldStop()
7549 
    oprot.writeStructEnd()
7550 
 
7551 
  def validate(self):
7552 
    return
7553 
 
7554 
 
7555 
  def __repr__(self):
7556 
    L = ['%s=%r' % (key, value)
7557 
      for key, value in self.__dict__.iteritems()]
7558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7559 
 
7560 
  def __eq__(self, other):
7561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7562 
 
7563 
  def __ne__(self, other):
7564 
    return not (self == other)
7565 
 
7566 
class getAllItems_args:
7567 
  """
7568 
  Attributes:
7569 
   - isActive
7570 
  """
7571 
 
7572 
  thrift_spec = (
7573 
    None, # 0
7574 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7575 
  )
7576 
 
7577 
  def __init__(self, isActive=None,):
7578 
    self.isActive = isActive
7579 
 
7580 
  def read(self, iprot):
7581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7583 
      return
7584 
    iprot.readStructBegin()
7585 
    while True:
7586 
      (fname, ftype, fid) = iprot.readFieldBegin()
7587 
      if ftype == TType.STOP:
7588 
        break
7589 
      if fid == 1:
7590 
        if ftype == TType.BOOL:
7591 
          self.isActive = iprot.readBool();
7592 
        else:
7593 
          iprot.skip(ftype)
7594 
      else:
7595 
        iprot.skip(ftype)
7596 
      iprot.readFieldEnd()
7597 
    iprot.readStructEnd()
7598 
 
7599 
  def write(self, oprot):
7600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7602 
      return
7603 
    oprot.writeStructBegin('getAllItems_args')
7604 
    if self.isActive is not None:
7605 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7606 
      oprot.writeBool(self.isActive)
7607 
      oprot.writeFieldEnd()
7608 
    oprot.writeFieldStop()
7609 
    oprot.writeStructEnd()
7610 
 
7611 
  def validate(self):
7612 
    return
7613 
 
7614 
 
7615 
  def __repr__(self):
7616 
    L = ['%s=%r' % (key, value)
7617 
      for key, value in self.__dict__.iteritems()]
7618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7619 
 
7620 
  def __eq__(self, other):
7621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7622 
 
7623 
  def __ne__(self, other):
7624 
    return not (self == other)
7625 
 
7626 
class getAllItems_result:
7627 
  """
7628 
  Attributes:
7629 
   - success
7630 
   - cex
7631 
  """
7632 
 
7633 
  thrift_spec = (
7634 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7635 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7636 
  )
7637 
 
7638 
  def __init__(self, success=None, cex=None,):
7639 
    self.success = success
7640 
    self.cex = cex
7641 
 
7642 
  def read(self, iprot):
7643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7645 
      return
7646 
    iprot.readStructBegin()
7647 
    while True:
7648 
      (fname, ftype, fid) = iprot.readFieldBegin()
7649 
      if ftype == TType.STOP:
7650 
        break
7651 
      if fid == 0:
7652 
        if ftype == TType.LIST:
7653 
          self.success = []
8590 kshitij.so 7654 
          (_etype63, _size60) = iprot.readListBegin()
7655 
          for _i64 in xrange(_size60):
7656 
            _elem65 = Item()
7657 
            _elem65.read(iprot)
7658 
            self.success.append(_elem65)
5944 mandeep.dh 7659 
          iprot.readListEnd()
7660 
        else:
7661 
          iprot.skip(ftype)
7662 
      elif fid == 1:
7663 
        if ftype == TType.STRUCT:
7664 
          self.cex = CatalogServiceException()
7665 
          self.cex.read(iprot)
7666 
        else:
7667 
          iprot.skip(ftype)
7668 
      else:
7669 
        iprot.skip(ftype)
7670 
      iprot.readFieldEnd()
7671 
    iprot.readStructEnd()
7672 
 
7673 
  def write(self, oprot):
7674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7676 
      return
7677 
    oprot.writeStructBegin('getAllItems_result')
7678 
    if self.success is not None:
7679 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7680 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7681 
      for iter66 in self.success:
7682 
        iter66.write(oprot)
5944 mandeep.dh 7683 
      oprot.writeListEnd()
7684 
      oprot.writeFieldEnd()
7685 
    if self.cex is not None:
7686 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7687 
      self.cex.write(oprot)
7688 
      oprot.writeFieldEnd()
7689 
    oprot.writeFieldStop()
7690 
    oprot.writeStructEnd()
7691 
 
7692 
  def validate(self):
7693 
    return
7694 
 
7695 
 
7696 
  def __repr__(self):
7697 
    L = ['%s=%r' % (key, value)
7698 
      for key, value in self.__dict__.iteritems()]
7699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7700 
 
7701 
  def __eq__(self, other):
7702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7703 
 
7704 
  def __ne__(self, other):
7705 
    return not (self == other)
7706 
 
7707 
class getAllItemsByStatus_args:
7708 
  """
7709 
  Attributes:
7710 
   - itemStatus
7711 
  """
7712 
 
7713 
  thrift_spec = (
7714 
    None, # 0
7715 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7716 
  )
7717 
 
7718 
  def __init__(self, itemStatus=None,):
7719 
    self.itemStatus = itemStatus
7720 
 
7721 
  def read(self, iprot):
7722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7724 
      return
7725 
    iprot.readStructBegin()
7726 
    while True:
7727 
      (fname, ftype, fid) = iprot.readFieldBegin()
7728 
      if ftype == TType.STOP:
7729 
        break
7730 
      if fid == 1:
7731 
        if ftype == TType.I32:
7732 
          self.itemStatus = iprot.readI32();
7733 
        else:
7734 
          iprot.skip(ftype)
7735 
      else:
7736 
        iprot.skip(ftype)
7737 
      iprot.readFieldEnd()
7738 
    iprot.readStructEnd()
7739 
 
7740 
  def write(self, oprot):
7741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7743 
      return
7744 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7745 
    if self.itemStatus is not None:
7746 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7747 
      oprot.writeI32(self.itemStatus)
7748 
      oprot.writeFieldEnd()
7749 
    oprot.writeFieldStop()
7750 
    oprot.writeStructEnd()
7751 
 
7752 
  def validate(self):
7753 
    return
7754 
 
7755 
 
7756 
  def __repr__(self):
7757 
    L = ['%s=%r' % (key, value)
7758 
      for key, value in self.__dict__.iteritems()]
7759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7760 
 
7761 
  def __eq__(self, other):
7762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7763 
 
7764 
  def __ne__(self, other):
7765 
    return not (self == other)
7766 
 
7767 
class getAllItemsByStatus_result:
7768 
  """
7769 
  Attributes:
7770 
   - success
7771 
   - cex
7772 
  """
7773 
 
7774 
  thrift_spec = (
7775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7776 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7777 
  )
7778 
 
7779 
  def __init__(self, success=None, cex=None,):
7780 
    self.success = success
7781 
    self.cex = cex
7782 
 
7783 
  def read(self, iprot):
7784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7786 
      return
7787 
    iprot.readStructBegin()
7788 
    while True:
7789 
      (fname, ftype, fid) = iprot.readFieldBegin()
7790 
      if ftype == TType.STOP:
7791 
        break
7792 
      if fid == 0:
7793 
        if ftype == TType.LIST:
7794 
          self.success = []
8590 kshitij.so 7795 
          (_etype70, _size67) = iprot.readListBegin()
7796 
          for _i71 in xrange(_size67):
7797 
            _elem72 = Item()
7798 
            _elem72.read(iprot)
7799 
            self.success.append(_elem72)
5944 mandeep.dh 7800 
          iprot.readListEnd()
7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      elif fid == 1:
7804 
        if ftype == TType.STRUCT:
7805 
          self.cex = CatalogServiceException()
7806 
          self.cex.read(iprot)
7807 
        else:
7808 
          iprot.skip(ftype)
7809 
      else:
7810 
        iprot.skip(ftype)
7811 
      iprot.readFieldEnd()
7812 
    iprot.readStructEnd()
7813 
 
7814 
  def write(self, oprot):
7815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7817 
      return
7818 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7819 
    if self.success is not None:
7820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7822 
      for iter73 in self.success:
7823 
        iter73.write(oprot)
5944 mandeep.dh 7824 
      oprot.writeListEnd()
7825 
      oprot.writeFieldEnd()
7826 
    if self.cex is not None:
7827 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7828 
      self.cex.write(oprot)
7829 
      oprot.writeFieldEnd()
7830 
    oprot.writeFieldStop()
7831 
    oprot.writeStructEnd()
7832 
 
7833 
  def validate(self):
7834 
    return
7835 
 
7836 
 
7837 
  def __repr__(self):
7838 
    L = ['%s=%r' % (key, value)
7839 
      for key, value in self.__dict__.iteritems()]
7840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7841 
 
7842 
  def __eq__(self, other):
7843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7844 
 
7845 
  def __ne__(self, other):
7846 
    return not (self == other)
7847 
 
7848 
class markItemAsContentComplete_args:
7849 
  """
7850 
  Attributes:
7851 
   - entityId
7852 
   - category
7853 
   - brand
7854 
   - modelName
7855 
   - modelNumber
7856 
  """
7857 
 
7858 
  thrift_spec = (
7859 
    None, # 0
7860 
    (1, TType.I64, 'entityId', None, None, ), # 1
7861 
    (2, TType.I64, 'category', None, None, ), # 2
7862 
    (3, TType.STRING, 'brand', None, None, ), # 3
7863 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7864 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7865 
  )
7866 
 
7867 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7868 
    self.entityId = entityId
7869 
    self.category = category
7870 
    self.brand = brand
7871 
    self.modelName = modelName
7872 
    self.modelNumber = modelNumber
7873 
 
7874 
  def read(self, iprot):
7875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7877 
      return
7878 
    iprot.readStructBegin()
7879 
    while True:
7880 
      (fname, ftype, fid) = iprot.readFieldBegin()
7881 
      if ftype == TType.STOP:
7882 
        break
7883 
      if fid == 1:
7884 
        if ftype == TType.I64:
7885 
          self.entityId = iprot.readI64();
7886 
        else:
7887 
          iprot.skip(ftype)
7888 
      elif fid == 2:
7889 
        if ftype == TType.I64:
7890 
          self.category = iprot.readI64();
7891 
        else:
7892 
          iprot.skip(ftype)
7893 
      elif fid == 3:
7894 
        if ftype == TType.STRING:
7895 
          self.brand = iprot.readString();
7896 
        else:
7897 
          iprot.skip(ftype)
7898 
      elif fid == 4:
7899 
        if ftype == TType.STRING:
7900 
          self.modelName = iprot.readString();
7901 
        else:
7902 
          iprot.skip(ftype)
7903 
      elif fid == 5:
7904 
        if ftype == TType.STRING:
7905 
          self.modelNumber = iprot.readString();
7906 
        else:
7907 
          iprot.skip(ftype)
7908 
      else:
7909 
        iprot.skip(ftype)
7910 
      iprot.readFieldEnd()
7911 
    iprot.readStructEnd()
7912 
 
7913 
  def write(self, oprot):
7914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7916 
      return
7917 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7918 
    if self.entityId is not None:
7919 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7920 
      oprot.writeI64(self.entityId)
7921 
      oprot.writeFieldEnd()
7922 
    if self.category is not None:
7923 
      oprot.writeFieldBegin('category', TType.I64, 2)
7924 
      oprot.writeI64(self.category)
7925 
      oprot.writeFieldEnd()
7926 
    if self.brand is not None:
7927 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7928 
      oprot.writeString(self.brand)
7929 
      oprot.writeFieldEnd()
7930 
    if self.modelName is not None:
7931 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7932 
      oprot.writeString(self.modelName)
7933 
      oprot.writeFieldEnd()
7934 
    if self.modelNumber is not None:
7935 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7936 
      oprot.writeString(self.modelNumber)
7937 
      oprot.writeFieldEnd()
7938 
    oprot.writeFieldStop()
7939 
    oprot.writeStructEnd()
7940 
 
7941 
  def validate(self):
7942 
    return
7943 
 
7944 
 
7945 
  def __repr__(self):
7946 
    L = ['%s=%r' % (key, value)
7947 
      for key, value in self.__dict__.iteritems()]
7948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7949 
 
7950 
  def __eq__(self, other):
7951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7952 
 
7953 
  def __ne__(self, other):
7954 
    return not (self == other)
7955 
 
7956 
class markItemAsContentComplete_result:
7957 
  """
7958 
  Attributes:
7959 
   - success
7960 
   - cex
7961 
  """
7962 
 
7963 
  thrift_spec = (
7964 
    (0, TType.BOOL, 'success', None, None, ), # 0
7965 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7966 
  )
7967 
 
7968 
  def __init__(self, success=None, cex=None,):
7969 
    self.success = success
7970 
    self.cex = cex
7971 
 
7972 
  def read(self, iprot):
7973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7975 
      return
7976 
    iprot.readStructBegin()
7977 
    while True:
7978 
      (fname, ftype, fid) = iprot.readFieldBegin()
7979 
      if ftype == TType.STOP:
7980 
        break
7981 
      if fid == 0:
7982 
        if ftype == TType.BOOL:
7983 
          self.success = iprot.readBool();
7984 
        else:
7985 
          iprot.skip(ftype)
7986 
      elif fid == 1:
7987 
        if ftype == TType.STRUCT:
7988 
          self.cex = CatalogServiceException()
7989 
          self.cex.read(iprot)
7990 
        else:
7991 
          iprot.skip(ftype)
7992 
      else:
7993 
        iprot.skip(ftype)
7994 
      iprot.readFieldEnd()
7995 
    iprot.readStructEnd()
7996 
 
7997 
  def write(self, oprot):
7998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8000 
      return
8001 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8002 
    if self.success is not None:
8003 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8004 
      oprot.writeBool(self.success)
8005 
      oprot.writeFieldEnd()
8006 
    if self.cex is not None:
8007 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8008 
      self.cex.write(oprot)
8009 
      oprot.writeFieldEnd()
8010 
    oprot.writeFieldStop()
8011 
    oprot.writeStructEnd()
8012 
 
8013 
  def validate(self):
8014 
    return
8015 
 
8016 
 
8017 
  def __repr__(self):
8018 
    L = ['%s=%r' % (key, value)
8019 
      for key, value in self.__dict__.iteritems()]
8020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8021 
 
8022 
  def __eq__(self, other):
8023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8024 
 
8025 
  def __ne__(self, other):
8026 
    return not (self == other)
8027 
 
8028 
class getAllItemsInRange_args:
8029 
  """
8030 
  Attributes:
8031 
   - offset
8032 
   - limit
8033 
  """
8034 
 
8035 
  thrift_spec = (
8036 
    None, # 0
8037 
    (1, TType.I64, 'offset', None, None, ), # 1
8038 
    (2, TType.I64, 'limit', None, None, ), # 2
8039 
  )
8040 
 
8041 
  def __init__(self, offset=None, limit=None,):
8042 
    self.offset = offset
8043 
    self.limit = limit
8044 
 
8045 
  def read(self, iprot):
8046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8048 
      return
8049 
    iprot.readStructBegin()
8050 
    while True:
8051 
      (fname, ftype, fid) = iprot.readFieldBegin()
8052 
      if ftype == TType.STOP:
8053 
        break
8054 
      if fid == 1:
8055 
        if ftype == TType.I64:
8056 
          self.offset = iprot.readI64();
8057 
        else:
8058 
          iprot.skip(ftype)
8059 
      elif fid == 2:
8060 
        if ftype == TType.I64:
8061 
          self.limit = iprot.readI64();
8062 
        else:
8063 
          iprot.skip(ftype)
8064 
      else:
8065 
        iprot.skip(ftype)
8066 
      iprot.readFieldEnd()
8067 
    iprot.readStructEnd()
8068 
 
8069 
  def write(self, oprot):
8070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8072 
      return
8073 
    oprot.writeStructBegin('getAllItemsInRange_args')
8074 
    if self.offset is not None:
8075 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8076 
      oprot.writeI64(self.offset)
8077 
      oprot.writeFieldEnd()
8078 
    if self.limit is not None:
8079 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8080 
      oprot.writeI64(self.limit)
8081 
      oprot.writeFieldEnd()
8082 
    oprot.writeFieldStop()
8083 
    oprot.writeStructEnd()
8084 
 
8085 
  def validate(self):
8086 
    return
8087 
 
8088 
 
8089 
  def __repr__(self):
8090 
    L = ['%s=%r' % (key, value)
8091 
      for key, value in self.__dict__.iteritems()]
8092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8093 
 
8094 
  def __eq__(self, other):
8095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8096 
 
8097 
  def __ne__(self, other):
8098 
    return not (self == other)
8099 
 
8100 
class getAllItemsInRange_result:
8101 
  """
8102 
  Attributes:
8103 
   - success
8104 
   - cex
8105 
  """
8106 
 
8107 
  thrift_spec = (
8108 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8109 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8110 
  )
8111 
 
8112 
  def __init__(self, success=None, cex=None,):
8113 
    self.success = success
8114 
    self.cex = cex
8115 
 
8116 
  def read(self, iprot):
8117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8119 
      return
8120 
    iprot.readStructBegin()
8121 
    while True:
8122 
      (fname, ftype, fid) = iprot.readFieldBegin()
8123 
      if ftype == TType.STOP:
8124 
        break
8125 
      if fid == 0:
8126 
        if ftype == TType.LIST:
8127 
          self.success = []
8590 kshitij.so 8128 
          (_etype77, _size74) = iprot.readListBegin()
8129 
          for _i78 in xrange(_size74):
8130 
            _elem79 = Item()
8131 
            _elem79.read(iprot)
8132 
            self.success.append(_elem79)
5944 mandeep.dh 8133 
          iprot.readListEnd()
8134 
        else:
8135 
          iprot.skip(ftype)
8136 
      elif fid == 1:
8137 
        if ftype == TType.STRUCT:
8138 
          self.cex = CatalogServiceException()
8139 
          self.cex.read(iprot)
8140 
        else:
8141 
          iprot.skip(ftype)
8142 
      else:
8143 
        iprot.skip(ftype)
8144 
      iprot.readFieldEnd()
8145 
    iprot.readStructEnd()
8146 
 
8147 
  def write(self, oprot):
8148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8150 
      return
8151 
    oprot.writeStructBegin('getAllItemsInRange_result')
8152 
    if self.success is not None:
8153 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8154 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8155 
      for iter80 in self.success:
8156 
        iter80.write(oprot)
5944 mandeep.dh 8157 
      oprot.writeListEnd()
8158 
      oprot.writeFieldEnd()
8159 
    if self.cex is not None:
8160 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8161 
      self.cex.write(oprot)
8162 
      oprot.writeFieldEnd()
8163 
    oprot.writeFieldStop()
8164 
    oprot.writeStructEnd()
8165 
 
8166 
  def validate(self):
8167 
    return
8168 
 
8169 
 
8170 
  def __repr__(self):
8171 
    L = ['%s=%r' % (key, value)
8172 
      for key, value in self.__dict__.iteritems()]
8173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8174 
 
8175 
  def __eq__(self, other):
8176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8177 
 
8178 
  def __ne__(self, other):
8179 
    return not (self == other)
8180 
 
8181 
class getAllItemsByStatusInRange_args:
8182 
  """
8183 
  Attributes:
8184 
   - itemStatus
8185 
   - offset
8186 
   - limit
8187 
  """
8188 
 
8189 
  thrift_spec = (
8190 
    None, # 0
8191 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8192 
    (2, TType.I64, 'offset', None, None, ), # 2
8193 
    (3, TType.I64, 'limit', None, None, ), # 3
8194 
  )
8195 
 
8196 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8197 
    self.itemStatus = itemStatus
8198 
    self.offset = offset
8199 
    self.limit = limit
8200 
 
8201 
  def read(self, iprot):
8202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8204 
      return
8205 
    iprot.readStructBegin()
8206 
    while True:
8207 
      (fname, ftype, fid) = iprot.readFieldBegin()
8208 
      if ftype == TType.STOP:
8209 
        break
8210 
      if fid == 1:
8211 
        if ftype == TType.I32:
8212 
          self.itemStatus = iprot.readI32();
8213 
        else:
8214 
          iprot.skip(ftype)
8215 
      elif fid == 2:
8216 
        if ftype == TType.I64:
8217 
          self.offset = iprot.readI64();
8218 
        else:
8219 
          iprot.skip(ftype)
8220 
      elif fid == 3:
8221 
        if ftype == TType.I64:
8222 
          self.limit = iprot.readI64();
8223 
        else:
8224 
          iprot.skip(ftype)
8225 
      else:
8226 
        iprot.skip(ftype)
8227 
      iprot.readFieldEnd()
8228 
    iprot.readStructEnd()
8229 
 
8230 
  def write(self, oprot):
8231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8233 
      return
8234 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8235 
    if self.itemStatus is not None:
8236 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8237 
      oprot.writeI32(self.itemStatus)
8238 
      oprot.writeFieldEnd()
8239 
    if self.offset is not None:
8240 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8241 
      oprot.writeI64(self.offset)
8242 
      oprot.writeFieldEnd()
8243 
    if self.limit is not None:
8244 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8245 
      oprot.writeI64(self.limit)
8246 
      oprot.writeFieldEnd()
8247 
    oprot.writeFieldStop()
8248 
    oprot.writeStructEnd()
8249 
 
8250 
  def validate(self):
8251 
    return
8252 
 
8253 
 
8254 
  def __repr__(self):
8255 
    L = ['%s=%r' % (key, value)
8256 
      for key, value in self.__dict__.iteritems()]
8257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8258 
 
8259 
  def __eq__(self, other):
8260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8261 
 
8262 
  def __ne__(self, other):
8263 
    return not (self == other)
8264 
 
8265 
class getAllItemsByStatusInRange_result:
8266 
  """
8267 
  Attributes:
8268 
   - success
8269 
   - cex
8270 
  """
8271 
 
8272 
  thrift_spec = (
8273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8274 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8275 
  )
8276 
 
8277 
  def __init__(self, success=None, cex=None,):
8278 
    self.success = success
8279 
    self.cex = cex
8280 
 
8281 
  def read(self, iprot):
8282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8284 
      return
8285 
    iprot.readStructBegin()
8286 
    while True:
8287 
      (fname, ftype, fid) = iprot.readFieldBegin()
8288 
      if ftype == TType.STOP:
8289 
        break
8290 
      if fid == 0:
8291 
        if ftype == TType.LIST:
8292 
          self.success = []
8590 kshitij.so 8293 
          (_etype84, _size81) = iprot.readListBegin()
8294 
          for _i85 in xrange(_size81):
8295 
            _elem86 = Item()
8296 
            _elem86.read(iprot)
8297 
            self.success.append(_elem86)
5944 mandeep.dh 8298 
          iprot.readListEnd()
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      elif fid == 1:
8302 
        if ftype == TType.STRUCT:
8303 
          self.cex = CatalogServiceException()
8304 
          self.cex.read(iprot)
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      else:
8308 
        iprot.skip(ftype)
8309 
      iprot.readFieldEnd()
8310 
    iprot.readStructEnd()
8311 
 
8312 
  def write(self, oprot):
8313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8315 
      return
8316 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8317 
    if self.success is not None:
8318 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8319 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8320 
      for iter87 in self.success:
8321 
        iter87.write(oprot)
5944 mandeep.dh 8322 
      oprot.writeListEnd()
8323 
      oprot.writeFieldEnd()
8324 
    if self.cex is not None:
8325 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8326 
      self.cex.write(oprot)
8327 
      oprot.writeFieldEnd()
8328 
    oprot.writeFieldStop()
8329 
    oprot.writeStructEnd()
8330 
 
8331 
  def validate(self):
8332 
    return
8333 
 
8334 
 
8335 
  def __repr__(self):
8336 
    L = ['%s=%r' % (key, value)
8337 
      for key, value in self.__dict__.iteritems()]
8338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8339 
 
8340 
  def __eq__(self, other):
8341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8342 
 
8343 
  def __ne__(self, other):
8344 
    return not (self == other)
8345 
 
8346 
class getItemCountByStatus_args:
8347 
  """
8348 
  Attributes:
8349 
   - useStatus
8350 
   - itemStatus
8351 
  """
8352 
 
8353 
  thrift_spec = (
8354 
    None, # 0
8355 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8356 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8357 
  )
8358 
 
8359 
  def __init__(self, useStatus=None, itemStatus=None,):
8360 
    self.useStatus = useStatus
8361 
    self.itemStatus = itemStatus
8362 
 
8363 
  def read(self, iprot):
8364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8366 
      return
8367 
    iprot.readStructBegin()
8368 
    while True:
8369 
      (fname, ftype, fid) = iprot.readFieldBegin()
8370 
      if ftype == TType.STOP:
8371 
        break
8372 
      if fid == 1:
8373 
        if ftype == TType.BOOL:
8374 
          self.useStatus = iprot.readBool();
8375 
        else:
8376 
          iprot.skip(ftype)
8377 
      elif fid == 2:
8378 
        if ftype == TType.I32:
8379 
          self.itemStatus = iprot.readI32();
8380 
        else:
8381 
          iprot.skip(ftype)
8382 
      else:
8383 
        iprot.skip(ftype)
8384 
      iprot.readFieldEnd()
8385 
    iprot.readStructEnd()
8386 
 
8387 
  def write(self, oprot):
8388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8390 
      return
8391 
    oprot.writeStructBegin('getItemCountByStatus_args')
8392 
    if self.useStatus is not None:
8393 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8394 
      oprot.writeBool(self.useStatus)
8395 
      oprot.writeFieldEnd()
8396 
    if self.itemStatus is not None:
8397 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8398 
      oprot.writeI32(self.itemStatus)
8399 
      oprot.writeFieldEnd()
8400 
    oprot.writeFieldStop()
8401 
    oprot.writeStructEnd()
8402 
 
8403 
  def validate(self):
8404 
    return
8405 
 
8406 
 
8407 
  def __repr__(self):
8408 
    L = ['%s=%r' % (key, value)
8409 
      for key, value in self.__dict__.iteritems()]
8410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8411 
 
8412 
  def __eq__(self, other):
8413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8414 
 
8415 
  def __ne__(self, other):
8416 
    return not (self == other)
8417 
 
8418 
class getItemCountByStatus_result:
8419 
  """
8420 
  Attributes:
8421 
   - success
8422 
  """
8423 
 
8424 
  thrift_spec = (
8425 
    (0, TType.I32, 'success', None, None, ), # 0
8426 
  )
8427 
 
8428 
  def __init__(self, success=None,):
8429 
    self.success = success
8430 
 
8431 
  def read(self, iprot):
8432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8434 
      return
8435 
    iprot.readStructBegin()
8436 
    while True:
8437 
      (fname, ftype, fid) = iprot.readFieldBegin()
8438 
      if ftype == TType.STOP:
8439 
        break
8440 
      if fid == 0:
8441 
        if ftype == TType.I32:
8442 
          self.success = iprot.readI32();
8443 
        else:
8444 
          iprot.skip(ftype)
8445 
      else:
8446 
        iprot.skip(ftype)
8447 
      iprot.readFieldEnd()
8448 
    iprot.readStructEnd()
8449 
 
8450 
  def write(self, oprot):
8451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8453 
      return
8454 
    oprot.writeStructBegin('getItemCountByStatus_result')
8455 
    if self.success is not None:
8456 
      oprot.writeFieldBegin('success', TType.I32, 0)
8457 
      oprot.writeI32(self.success)
8458 
      oprot.writeFieldEnd()
8459 
    oprot.writeFieldStop()
8460 
    oprot.writeStructEnd()
8461 
 
8462 
  def validate(self):
8463 
    return
8464 
 
8465 
 
8466 
  def __repr__(self):
8467 
    L = ['%s=%r' % (key, value)
8468 
      for key, value in self.__dict__.iteritems()]
8469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8470 
 
8471 
  def __eq__(self, other):
8472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8473 
 
8474 
  def __ne__(self, other):
8475 
    return not (self == other)
8476 
 
8477 
class getBestSellers_args:
8478 
 
8479 
  thrift_spec = (
8480 
  )
8481 
 
8482 
  def read(self, iprot):
8483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8485 
      return
8486 
    iprot.readStructBegin()
8487 
    while True:
8488 
      (fname, ftype, fid) = iprot.readFieldBegin()
8489 
      if ftype == TType.STOP:
8490 
        break
8491 
      else:
8492 
        iprot.skip(ftype)
8493 
      iprot.readFieldEnd()
8494 
    iprot.readStructEnd()
8495 
 
8496 
  def write(self, oprot):
8497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8499 
      return
8500 
    oprot.writeStructBegin('getBestSellers_args')
8501 
    oprot.writeFieldStop()
8502 
    oprot.writeStructEnd()
8503 
 
8504 
  def validate(self):
8505 
    return
8506 
 
8507 
 
8508 
  def __repr__(self):
8509 
    L = ['%s=%r' % (key, value)
8510 
      for key, value in self.__dict__.iteritems()]
8511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8512 
 
8513 
  def __eq__(self, other):
8514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8515 
 
8516 
  def __ne__(self, other):
8517 
    return not (self == other)
8518 
 
8519 
class getBestSellers_result:
8520 
  """
8521 
  Attributes:
8522 
   - success
8523 
   - isex
8524 
  """
8525 
 
8526 
  thrift_spec = (
8527 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8528 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8529 
  )
8530 
 
8531 
  def __init__(self, success=None, isex=None,):
8532 
    self.success = success
8533 
    self.isex = isex
8534 
 
8535 
  def read(self, iprot):
8536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8538 
      return
8539 
    iprot.readStructBegin()
8540 
    while True:
8541 
      (fname, ftype, fid) = iprot.readFieldBegin()
8542 
      if ftype == TType.STOP:
8543 
        break
8544 
      if fid == 0:
8545 
        if ftype == TType.LIST:
8546 
          self.success = []
8590 kshitij.so 8547 
          (_etype91, _size88) = iprot.readListBegin()
8548 
          for _i92 in xrange(_size88):
8549 
            _elem93 = Item()
8550 
            _elem93.read(iprot)
8551 
            self.success.append(_elem93)
5944 mandeep.dh 8552 
          iprot.readListEnd()
8553 
        else:
8554 
          iprot.skip(ftype)
8555 
      elif fid == 1:
8556 
        if ftype == TType.STRUCT:
8557 
          self.isex = CatalogServiceException()
8558 
          self.isex.read(iprot)
8559 
        else:
8560 
          iprot.skip(ftype)
8561 
      else:
8562 
        iprot.skip(ftype)
8563 
      iprot.readFieldEnd()
8564 
    iprot.readStructEnd()
8565 
 
8566 
  def write(self, oprot):
8567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8569 
      return
8570 
    oprot.writeStructBegin('getBestSellers_result')
8571 
    if self.success is not None:
8572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8573 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8574 
      for iter94 in self.success:
8575 
        iter94.write(oprot)
5944 mandeep.dh 8576 
      oprot.writeListEnd()
8577 
      oprot.writeFieldEnd()
8578 
    if self.isex is not None:
8579 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8580 
      self.isex.write(oprot)
8581 
      oprot.writeFieldEnd()
8582 
    oprot.writeFieldStop()
8583 
    oprot.writeStructEnd()
8584 
 
8585 
  def validate(self):
8586 
    return
8587 
 
8588 
 
8589 
  def __repr__(self):
8590 
    L = ['%s=%r' % (key, value)
8591 
      for key, value in self.__dict__.iteritems()]
8592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8593 
 
8594 
  def __eq__(self, other):
8595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8596 
 
8597 
  def __ne__(self, other):
8598 
    return not (self == other)
8599 
 
8600 
class getBestSellersCatalogIds_args:
8601 
  """
8602 
  Attributes:
8603 
   - beginIndex
8604 
   - totalItems
8605 
   - brand
8606 
   - category
8607 
  """
8608 
 
8609 
  thrift_spec = (
8610 
    None, # 0
8611 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8612 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8613 
    (3, TType.STRING, 'brand', None, None, ), # 3
8614 
    (4, TType.I64, 'category', None, None, ), # 4
8615 
  )
8616 
 
8617 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8618 
    self.beginIndex = beginIndex
8619 
    self.totalItems = totalItems
8620 
    self.brand = brand
8621 
    self.category = category
8622 
 
8623 
  def read(self, iprot):
8624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8626 
      return
8627 
    iprot.readStructBegin()
8628 
    while True:
8629 
      (fname, ftype, fid) = iprot.readFieldBegin()
8630 
      if ftype == TType.STOP:
8631 
        break
8632 
      if fid == 1:
8633 
        if ftype == TType.I64:
8634 
          self.beginIndex = iprot.readI64();
8635 
        else:
8636 
          iprot.skip(ftype)
8637 
      elif fid == 2:
8638 
        if ftype == TType.I64:
8639 
          self.totalItems = iprot.readI64();
8640 
        else:
8641 
          iprot.skip(ftype)
8642 
      elif fid == 3:
8643 
        if ftype == TType.STRING:
8644 
          self.brand = iprot.readString();
8645 
        else:
8646 
          iprot.skip(ftype)
8647 
      elif fid == 4:
8648 
        if ftype == TType.I64:
8649 
          self.category = iprot.readI64();
8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      else:
8653 
        iprot.skip(ftype)
8654 
      iprot.readFieldEnd()
8655 
    iprot.readStructEnd()
8656 
 
8657 
  def write(self, oprot):
8658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8660 
      return
8661 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8662 
    if self.beginIndex is not None:
8663 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8664 
      oprot.writeI64(self.beginIndex)
8665 
      oprot.writeFieldEnd()
8666 
    if self.totalItems is not None:
8667 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8668 
      oprot.writeI64(self.totalItems)
8669 
      oprot.writeFieldEnd()
8670 
    if self.brand is not None:
8671 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8672 
      oprot.writeString(self.brand)
8673 
      oprot.writeFieldEnd()
8674 
    if self.category is not None:
8675 
      oprot.writeFieldBegin('category', TType.I64, 4)
8676 
      oprot.writeI64(self.category)
8677 
      oprot.writeFieldEnd()
8678 
    oprot.writeFieldStop()
8679 
    oprot.writeStructEnd()
8680 
 
8681 
  def validate(self):
8682 
    return
8683 
 
8684 
 
8685 
  def __repr__(self):
8686 
    L = ['%s=%r' % (key, value)
8687 
      for key, value in self.__dict__.iteritems()]
8688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8689 
 
8690 
  def __eq__(self, other):
8691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8692 
 
8693 
  def __ne__(self, other):
8694 
    return not (self == other)
8695 
 
8696 
class getBestSellersCatalogIds_result:
8697 
  """
8698 
  Attributes:
8699 
   - success
8700 
   - cex
8701 
  """
8702 
 
8703 
  thrift_spec = (
8704 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8705 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8706 
  )
8707 
 
8708 
  def __init__(self, success=None, cex=None,):
8709 
    self.success = success
8710 
    self.cex = cex
8711 
 
8712 
  def read(self, iprot):
8713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8715 
      return
8716 
    iprot.readStructBegin()
8717 
    while True:
8718 
      (fname, ftype, fid) = iprot.readFieldBegin()
8719 
      if ftype == TType.STOP:
8720 
        break
8721 
      if fid == 0:
8722 
        if ftype == TType.LIST:
8723 
          self.success = []
8590 kshitij.so 8724 
          (_etype98, _size95) = iprot.readListBegin()
8725 
          for _i99 in xrange(_size95):
8726 
            _elem100 = iprot.readI64();
8727 
            self.success.append(_elem100)
5944 mandeep.dh 8728 
          iprot.readListEnd()
8729 
        else:
8730 
          iprot.skip(ftype)
8731 
      elif fid == 1:
8732 
        if ftype == TType.STRUCT:
8733 
          self.cex = CatalogServiceException()
8734 
          self.cex.read(iprot)
8735 
        else:
8736 
          iprot.skip(ftype)
8737 
      else:
8738 
        iprot.skip(ftype)
8739 
      iprot.readFieldEnd()
8740 
    iprot.readStructEnd()
8741 
 
8742 
  def write(self, oprot):
8743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8745 
      return
8746 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8747 
    if self.success is not None:
8748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8749 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 8750 
      for iter101 in self.success:
8751 
        oprot.writeI64(iter101)
5944 mandeep.dh 8752 
      oprot.writeListEnd()
8753 
      oprot.writeFieldEnd()
8754 
    if self.cex is not None:
8755 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8756 
      self.cex.write(oprot)
8757 
      oprot.writeFieldEnd()
8758 
    oprot.writeFieldStop()
8759 
    oprot.writeStructEnd()
8760 
 
8761 
  def validate(self):
8762 
    return
8763 
 
8764 
 
8765 
  def __repr__(self):
8766 
    L = ['%s=%r' % (key, value)
8767 
      for key, value in self.__dict__.iteritems()]
8768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8769 
 
8770 
  def __eq__(self, other):
8771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8772 
 
8773 
  def __ne__(self, other):
8774 
    return not (self == other)
8775 
 
8776 
class getBestSellersCount_args:
8777 
 
8778 
  thrift_spec = (
8779 
  )
8780 
 
8781 
  def read(self, iprot):
8782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8784 
      return
8785 
    iprot.readStructBegin()
8786 
    while True:
8787 
      (fname, ftype, fid) = iprot.readFieldBegin()
8788 
      if ftype == TType.STOP:
8789 
        break
8790 
      else:
8791 
        iprot.skip(ftype)
8792 
      iprot.readFieldEnd()
8793 
    iprot.readStructEnd()
8794 
 
8795 
  def write(self, oprot):
8796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8798 
      return
8799 
    oprot.writeStructBegin('getBestSellersCount_args')
8800 
    oprot.writeFieldStop()
8801 
    oprot.writeStructEnd()
8802 
 
8803 
  def validate(self):
8804 
    return
8805 
 
8806 
 
8807 
  def __repr__(self):
8808 
    L = ['%s=%r' % (key, value)
8809 
      for key, value in self.__dict__.iteritems()]
8810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8811 
 
8812 
  def __eq__(self, other):
8813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8814 
 
8815 
  def __ne__(self, other):
8816 
    return not (self == other)
8817 
 
8818 
class getBestSellersCount_result:
8819 
  """
8820 
  Attributes:
8821 
   - success
8822 
   - cex
8823 
  """
8824 
 
8825 
  thrift_spec = (
8826 
    (0, TType.I64, 'success', None, None, ), # 0
8827 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8828 
  )
8829 
 
8830 
  def __init__(self, success=None, cex=None,):
8831 
    self.success = success
8832 
    self.cex = cex
8833 
 
8834 
  def read(self, iprot):
8835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8837 
      return
8838 
    iprot.readStructBegin()
8839 
    while True:
8840 
      (fname, ftype, fid) = iprot.readFieldBegin()
8841 
      if ftype == TType.STOP:
8842 
        break
8843 
      if fid == 0:
8844 
        if ftype == TType.I64:
8845 
          self.success = iprot.readI64();
8846 
        else:
8847 
          iprot.skip(ftype)
8848 
      elif fid == 1:
8849 
        if ftype == TType.STRUCT:
8850 
          self.cex = CatalogServiceException()
8851 
          self.cex.read(iprot)
8852 
        else:
8853 
          iprot.skip(ftype)
8854 
      else:
8855 
        iprot.skip(ftype)
8856 
      iprot.readFieldEnd()
8857 
    iprot.readStructEnd()
8858 
 
8859 
  def write(self, oprot):
8860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8862 
      return
8863 
    oprot.writeStructBegin('getBestSellersCount_result')
8864 
    if self.success is not None:
8865 
      oprot.writeFieldBegin('success', TType.I64, 0)
8866 
      oprot.writeI64(self.success)
8867 
      oprot.writeFieldEnd()
8868 
    if self.cex is not None:
8869 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8870 
      self.cex.write(oprot)
8871 
      oprot.writeFieldEnd()
8872 
    oprot.writeFieldStop()
8873 
    oprot.writeStructEnd()
8874 
 
8875 
  def validate(self):
8876 
    return
8877 
 
8878 
 
8879 
  def __repr__(self):
8880 
    L = ['%s=%r' % (key, value)
8881 
      for key, value in self.__dict__.iteritems()]
8882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8883 
 
8884 
  def __eq__(self, other):
8885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8886 
 
8887 
  def __ne__(self, other):
8888 
    return not (self == other)
8889 
 
8890 
class getBestDeals_args:
8891 
 
8892 
  thrift_spec = (
8893 
  )
8894 
 
8895 
  def read(self, iprot):
8896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8898 
      return
8899 
    iprot.readStructBegin()
8900 
    while True:
8901 
      (fname, ftype, fid) = iprot.readFieldBegin()
8902 
      if ftype == TType.STOP:
8903 
        break
8904 
      else:
8905 
        iprot.skip(ftype)
8906 
      iprot.readFieldEnd()
8907 
    iprot.readStructEnd()
8908 
 
8909 
  def write(self, oprot):
8910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8912 
      return
8913 
    oprot.writeStructBegin('getBestDeals_args')
8914 
    oprot.writeFieldStop()
8915 
    oprot.writeStructEnd()
8916 
 
8917 
  def validate(self):
8918 
    return
8919 
 
8920 
 
8921 
  def __repr__(self):
8922 
    L = ['%s=%r' % (key, value)
8923 
      for key, value in self.__dict__.iteritems()]
8924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8925 
 
8926 
  def __eq__(self, other):
8927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8928 
 
8929 
  def __ne__(self, other):
8930 
    return not (self == other)
8931 
 
8932 
class getBestDeals_result:
8933 
  """
8934 
  Attributes:
8935 
   - success
8936 
   - isex
8937 
  """
8938 
 
8939 
  thrift_spec = (
8940 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8941 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8942 
  )
8943 
 
8944 
  def __init__(self, success=None, isex=None,):
8945 
    self.success = success
8946 
    self.isex = isex
8947 
 
8948 
  def read(self, iprot):
8949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8951 
      return
8952 
    iprot.readStructBegin()
8953 
    while True:
8954 
      (fname, ftype, fid) = iprot.readFieldBegin()
8955 
      if ftype == TType.STOP:
8956 
        break
8957 
      if fid == 0:
8958 
        if ftype == TType.LIST:
8959 
          self.success = []
8590 kshitij.so 8960 
          (_etype105, _size102) = iprot.readListBegin()
8961 
          for _i106 in xrange(_size102):
8962 
            _elem107 = Item()
8963 
            _elem107.read(iprot)
8964 
            self.success.append(_elem107)
5944 mandeep.dh 8965 
          iprot.readListEnd()
8966 
        else:
8967 
          iprot.skip(ftype)
8968 
      elif fid == 1:
8969 
        if ftype == TType.STRUCT:
8970 
          self.isex = CatalogServiceException()
8971 
          self.isex.read(iprot)
8972 
        else:
8973 
          iprot.skip(ftype)
8974 
      else:
8975 
        iprot.skip(ftype)
8976 
      iprot.readFieldEnd()
8977 
    iprot.readStructEnd()
8978 
 
8979 
  def write(self, oprot):
8980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8982 
      return
8983 
    oprot.writeStructBegin('getBestDeals_result')
8984 
    if self.success is not None:
8985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8987 
      for iter108 in self.success:
8988 
        iter108.write(oprot)
5944 mandeep.dh 8989 
      oprot.writeListEnd()
8990 
      oprot.writeFieldEnd()
8991 
    if self.isex is not None:
8992 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8993 
      self.isex.write(oprot)
8994 
      oprot.writeFieldEnd()
8995 
    oprot.writeFieldStop()
8996 
    oprot.writeStructEnd()
8997 
 
8998 
  def validate(self):
8999 
    return
9000 
 
9001 
 
9002 
  def __repr__(self):
9003 
    L = ['%s=%r' % (key, value)
9004 
      for key, value in self.__dict__.iteritems()]
9005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9006 
 
9007 
  def __eq__(self, other):
9008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9009 
 
9010 
  def __ne__(self, other):
9011 
    return not (self == other)
9012 
 
9013 
class getBestDealsCatalogIds_args:
9014 
  """
9015 
  Attributes:
9016 
   - beginIndex
9017 
   - totalItems
9018 
   - brand
9019 
   - category
9020 
  """
9021 
 
9022 
  thrift_spec = (
9023 
    None, # 0
9024 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9025 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9026 
    (3, TType.STRING, 'brand', None, None, ), # 3
9027 
    (4, TType.I64, 'category', None, None, ), # 4
9028 
  )
9029 
 
9030 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9031 
    self.beginIndex = beginIndex
9032 
    self.totalItems = totalItems
9033 
    self.brand = brand
9034 
    self.category = category
9035 
 
9036 
  def read(self, iprot):
9037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9039 
      return
9040 
    iprot.readStructBegin()
9041 
    while True:
9042 
      (fname, ftype, fid) = iprot.readFieldBegin()
9043 
      if ftype == TType.STOP:
9044 
        break
9045 
      if fid == 1:
9046 
        if ftype == TType.I64:
9047 
          self.beginIndex = iprot.readI64();
9048 
        else:
9049 
          iprot.skip(ftype)
9050 
      elif fid == 2:
9051 
        if ftype == TType.I64:
9052 
          self.totalItems = iprot.readI64();
9053 
        else:
9054 
          iprot.skip(ftype)
9055 
      elif fid == 3:
9056 
        if ftype == TType.STRING:
9057 
          self.brand = iprot.readString();
9058 
        else:
9059 
          iprot.skip(ftype)
9060 
      elif fid == 4:
9061 
        if ftype == TType.I64:
9062 
          self.category = iprot.readI64();
9063 
        else:
9064 
          iprot.skip(ftype)
9065 
      else:
9066 
        iprot.skip(ftype)
9067 
      iprot.readFieldEnd()
9068 
    iprot.readStructEnd()
9069 
 
9070 
  def write(self, oprot):
9071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9073 
      return
9074 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9075 
    if self.beginIndex is not None:
9076 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9077 
      oprot.writeI64(self.beginIndex)
9078 
      oprot.writeFieldEnd()
9079 
    if self.totalItems is not None:
9080 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9081 
      oprot.writeI64(self.totalItems)
9082 
      oprot.writeFieldEnd()
9083 
    if self.brand is not None:
9084 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9085 
      oprot.writeString(self.brand)
9086 
      oprot.writeFieldEnd()
9087 
    if self.category is not None:
9088 
      oprot.writeFieldBegin('category', TType.I64, 4)
9089 
      oprot.writeI64(self.category)
9090 
      oprot.writeFieldEnd()
9091 
    oprot.writeFieldStop()
9092 
    oprot.writeStructEnd()
9093 
 
9094 
  def validate(self):
9095 
    return
9096 
 
9097 
 
9098 
  def __repr__(self):
9099 
    L = ['%s=%r' % (key, value)
9100 
      for key, value in self.__dict__.iteritems()]
9101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9102 
 
9103 
  def __eq__(self, other):
9104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9105 
 
9106 
  def __ne__(self, other):
9107 
    return not (self == other)
9108 
 
9109 
class getBestDealsCatalogIds_result:
9110 
  """
9111 
  Attributes:
9112 
   - success
9113 
   - cex
9114 
  """
9115 
 
9116 
  thrift_spec = (
9117 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9118 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9119 
  )
9120 
 
9121 
  def __init__(self, success=None, cex=None,):
9122 
    self.success = success
9123 
    self.cex = cex
9124 
 
9125 
  def read(self, iprot):
9126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9128 
      return
9129 
    iprot.readStructBegin()
9130 
    while True:
9131 
      (fname, ftype, fid) = iprot.readFieldBegin()
9132 
      if ftype == TType.STOP:
9133 
        break
9134 
      if fid == 0:
9135 
        if ftype == TType.LIST:
9136 
          self.success = []
8590 kshitij.so 9137 
          (_etype112, _size109) = iprot.readListBegin()
9138 
          for _i113 in xrange(_size109):
9139 
            _elem114 = iprot.readI64();
9140 
            self.success.append(_elem114)
5944 mandeep.dh 9141 
          iprot.readListEnd()
9142 
        else:
9143 
          iprot.skip(ftype)
9144 
      elif fid == 1:
9145 
        if ftype == TType.STRUCT:
9146 
          self.cex = CatalogServiceException()
9147 
          self.cex.read(iprot)
9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
9159 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9160 
    if self.success is not None:
9161 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9162 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9163 
      for iter115 in self.success:
9164 
        oprot.writeI64(iter115)
5944 mandeep.dh 9165 
      oprot.writeListEnd()
9166 
      oprot.writeFieldEnd()
9167 
    if self.cex is not None:
9168 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9169 
      self.cex.write(oprot)
9170 
      oprot.writeFieldEnd()
9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
9189 
class getBestDealsCount_args:
9190 
 
9191 
  thrift_spec = (
9192 
  )
9193 
 
9194 
  def read(self, iprot):
9195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9197 
      return
9198 
    iprot.readStructBegin()
9199 
    while True:
9200 
      (fname, ftype, fid) = iprot.readFieldBegin()
9201 
      if ftype == TType.STOP:
9202 
        break
9203 
      else:
9204 
        iprot.skip(ftype)
9205 
      iprot.readFieldEnd()
9206 
    iprot.readStructEnd()
9207 
 
9208 
  def write(self, oprot):
9209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9211 
      return
9212 
    oprot.writeStructBegin('getBestDealsCount_args')
9213 
    oprot.writeFieldStop()
9214 
    oprot.writeStructEnd()
9215 
 
9216 
  def validate(self):
9217 
    return
9218 
 
9219 
 
9220 
  def __repr__(self):
9221 
    L = ['%s=%r' % (key, value)
9222 
      for key, value in self.__dict__.iteritems()]
9223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9224 
 
9225 
  def __eq__(self, other):
9226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9227 
 
9228 
  def __ne__(self, other):
9229 
    return not (self == other)
9230 
 
9231 
class getBestDealsCount_result:
9232 
  """
9233 
  Attributes:
9234 
   - success
9235 
   - cex
9236 
  """
9237 
 
9238 
  thrift_spec = (
9239 
    (0, TType.I64, 'success', None, None, ), # 0
9240 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9241 
  )
9242 
 
9243 
  def __init__(self, success=None, cex=None,):
9244 
    self.success = success
9245 
    self.cex = cex
9246 
 
9247 
  def read(self, iprot):
9248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9250 
      return
9251 
    iprot.readStructBegin()
9252 
    while True:
9253 
      (fname, ftype, fid) = iprot.readFieldBegin()
9254 
      if ftype == TType.STOP:
9255 
        break
9256 
      if fid == 0:
9257 
        if ftype == TType.I64:
9258 
          self.success = iprot.readI64();
9259 
        else:
9260 
          iprot.skip(ftype)
9261 
      elif fid == 1:
9262 
        if ftype == TType.STRUCT:
9263 
          self.cex = CatalogServiceException()
9264 
          self.cex.read(iprot)
9265 
        else:
9266 
          iprot.skip(ftype)
9267 
      else:
9268 
        iprot.skip(ftype)
9269 
      iprot.readFieldEnd()
9270 
    iprot.readStructEnd()
9271 
 
9272 
  def write(self, oprot):
9273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9275 
      return
9276 
    oprot.writeStructBegin('getBestDealsCount_result')
9277 
    if self.success is not None:
9278 
      oprot.writeFieldBegin('success', TType.I64, 0)
9279 
      oprot.writeI64(self.success)
9280 
      oprot.writeFieldEnd()
9281 
    if self.cex is not None:
9282 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9283 
      self.cex.write(oprot)
9284 
      oprot.writeFieldEnd()
9285 
    oprot.writeFieldStop()
9286 
    oprot.writeStructEnd()
9287 
 
9288 
  def validate(self):
9289 
    return
9290 
 
9291 
 
9292 
  def __repr__(self):
9293 
    L = ['%s=%r' % (key, value)
9294 
      for key, value in self.__dict__.iteritems()]
9295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9296 
 
9297 
  def __eq__(self, other):
9298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9299 
 
9300 
  def __ne__(self, other):
9301 
    return not (self == other)
9302 
 
9303 
class getComingSoon_args:
9304 
 
9305 
  thrift_spec = (
9306 
  )
9307 
 
9308 
  def read(self, iprot):
9309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9311 
      return
9312 
    iprot.readStructBegin()
9313 
    while True:
9314 
      (fname, ftype, fid) = iprot.readFieldBegin()
9315 
      if ftype == TType.STOP:
9316 
        break
9317 
      else:
9318 
        iprot.skip(ftype)
9319 
      iprot.readFieldEnd()
9320 
    iprot.readStructEnd()
9321 
 
9322 
  def write(self, oprot):
9323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9325 
      return
9326 
    oprot.writeStructBegin('getComingSoon_args')
9327 
    oprot.writeFieldStop()
9328 
    oprot.writeStructEnd()
9329 
 
9330 
  def validate(self):
9331 
    return
9332 
 
9333 
 
9334 
  def __repr__(self):
9335 
    L = ['%s=%r' % (key, value)
9336 
      for key, value in self.__dict__.iteritems()]
9337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9338 
 
9339 
  def __eq__(self, other):
9340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9341 
 
9342 
  def __ne__(self, other):
9343 
    return not (self == other)
9344 
 
9345 
class getComingSoon_result:
9346 
  """
9347 
  Attributes:
9348 
   - success
9349 
   - isex
9350 
  """
9351 
 
9352 
  thrift_spec = (
9353 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9354 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9355 
  )
9356 
 
9357 
  def __init__(self, success=None, isex=None,):
9358 
    self.success = success
9359 
    self.isex = isex
9360 
 
9361 
  def read(self, iprot):
9362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9364 
      return
9365 
    iprot.readStructBegin()
9366 
    while True:
9367 
      (fname, ftype, fid) = iprot.readFieldBegin()
9368 
      if ftype == TType.STOP:
9369 
        break
9370 
      if fid == 0:
9371 
        if ftype == TType.LIST:
9372 
          self.success = []
8590 kshitij.so 9373 
          (_etype119, _size116) = iprot.readListBegin()
9374 
          for _i120 in xrange(_size116):
9375 
            _elem121 = Item()
9376 
            _elem121.read(iprot)
9377 
            self.success.append(_elem121)
5944 mandeep.dh 9378 
          iprot.readListEnd()
9379 
        else:
9380 
          iprot.skip(ftype)
9381 
      elif fid == 1:
9382 
        if ftype == TType.STRUCT:
9383 
          self.isex = CatalogServiceException()
9384 
          self.isex.read(iprot)
9385 
        else:
9386 
          iprot.skip(ftype)
9387 
      else:
9388 
        iprot.skip(ftype)
9389 
      iprot.readFieldEnd()
9390 
    iprot.readStructEnd()
9391 
 
9392 
  def write(self, oprot):
9393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9395 
      return
9396 
    oprot.writeStructBegin('getComingSoon_result')
9397 
    if self.success is not None:
9398 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9399 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9400 
      for iter122 in self.success:
9401 
        iter122.write(oprot)
5944 mandeep.dh 9402 
      oprot.writeListEnd()
9403 
      oprot.writeFieldEnd()
9404 
    if self.isex is not None:
9405 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9406 
      self.isex.write(oprot)
9407 
      oprot.writeFieldEnd()
9408 
    oprot.writeFieldStop()
9409 
    oprot.writeStructEnd()
9410 
 
9411 
  def validate(self):
9412 
    return
9413 
 
9414 
 
9415 
  def __repr__(self):
9416 
    L = ['%s=%r' % (key, value)
9417 
      for key, value in self.__dict__.iteritems()]
9418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9419 
 
9420 
  def __eq__(self, other):
9421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9422 
 
9423 
  def __ne__(self, other):
9424 
    return not (self == other)
9425 
 
9426 
class getComingSoonCatalogIds_args:
9427 
  """
9428 
  Attributes:
9429 
   - beginIndex
9430 
   - totalItems
9431 
   - brand
9432 
   - category
9433 
  """
9434 
 
9435 
  thrift_spec = (
9436 
    None, # 0
9437 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9438 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9439 
    (3, TType.STRING, 'brand', None, None, ), # 3
9440 
    (4, TType.I64, 'category', None, None, ), # 4
9441 
  )
9442 
 
9443 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9444 
    self.beginIndex = beginIndex
9445 
    self.totalItems = totalItems
9446 
    self.brand = brand
9447 
    self.category = category
9448 
 
9449 
  def read(self, iprot):
9450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9452 
      return
9453 
    iprot.readStructBegin()
9454 
    while True:
9455 
      (fname, ftype, fid) = iprot.readFieldBegin()
9456 
      if ftype == TType.STOP:
9457 
        break
9458 
      if fid == 1:
9459 
        if ftype == TType.I64:
9460 
          self.beginIndex = iprot.readI64();
9461 
        else:
9462 
          iprot.skip(ftype)
9463 
      elif fid == 2:
9464 
        if ftype == TType.I64:
9465 
          self.totalItems = iprot.readI64();
9466 
        else:
9467 
          iprot.skip(ftype)
9468 
      elif fid == 3:
9469 
        if ftype == TType.STRING:
9470 
          self.brand = iprot.readString();
9471 
        else:
9472 
          iprot.skip(ftype)
9473 
      elif fid == 4:
9474 
        if ftype == TType.I64:
9475 
          self.category = iprot.readI64();
9476 
        else:
9477 
          iprot.skip(ftype)
9478 
      else:
9479 
        iprot.skip(ftype)
9480 
      iprot.readFieldEnd()
9481 
    iprot.readStructEnd()
9482 
 
9483 
  def write(self, oprot):
9484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9486 
      return
9487 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9488 
    if self.beginIndex is not None:
9489 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9490 
      oprot.writeI64(self.beginIndex)
9491 
      oprot.writeFieldEnd()
9492 
    if self.totalItems is not None:
9493 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9494 
      oprot.writeI64(self.totalItems)
9495 
      oprot.writeFieldEnd()
9496 
    if self.brand is not None:
9497 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9498 
      oprot.writeString(self.brand)
9499 
      oprot.writeFieldEnd()
9500 
    if self.category is not None:
9501 
      oprot.writeFieldBegin('category', TType.I64, 4)
9502 
      oprot.writeI64(self.category)
9503 
      oprot.writeFieldEnd()
9504 
    oprot.writeFieldStop()
9505 
    oprot.writeStructEnd()
9506 
 
9507 
  def validate(self):
9508 
    return
9509 
 
9510 
 
9511 
  def __repr__(self):
9512 
    L = ['%s=%r' % (key, value)
9513 
      for key, value in self.__dict__.iteritems()]
9514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9515 
 
9516 
  def __eq__(self, other):
9517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9518 
 
9519 
  def __ne__(self, other):
9520 
    return not (self == other)
9521 
 
9522 
class getComingSoonCatalogIds_result:
9523 
  """
9524 
  Attributes:
9525 
   - success
9526 
   - cex
9527 
  """
9528 
 
9529 
  thrift_spec = (
9530 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9531 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9532 
  )
9533 
 
9534 
  def __init__(self, success=None, cex=None,):
9535 
    self.success = success
9536 
    self.cex = cex
9537 
 
9538 
  def read(self, iprot):
9539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9541 
      return
9542 
    iprot.readStructBegin()
9543 
    while True:
9544 
      (fname, ftype, fid) = iprot.readFieldBegin()
9545 
      if ftype == TType.STOP:
9546 
        break
9547 
      if fid == 0:
9548 
        if ftype == TType.LIST:
9549 
          self.success = []
8590 kshitij.so 9550 
          (_etype126, _size123) = iprot.readListBegin()
9551 
          for _i127 in xrange(_size123):
9552 
            _elem128 = iprot.readI64();
9553 
            self.success.append(_elem128)
5944 mandeep.dh 9554 
          iprot.readListEnd()
9555 
        else:
9556 
          iprot.skip(ftype)
9557 
      elif fid == 1:
9558 
        if ftype == TType.STRUCT:
9559 
          self.cex = CatalogServiceException()
9560 
          self.cex.read(iprot)
9561 
        else:
9562 
          iprot.skip(ftype)
9563 
      else:
9564 
        iprot.skip(ftype)
9565 
      iprot.readFieldEnd()
9566 
    iprot.readStructEnd()
9567 
 
9568 
  def write(self, oprot):
9569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9571 
      return
9572 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9573 
    if self.success is not None:
9574 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9575 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9576 
      for iter129 in self.success:
9577 
        oprot.writeI64(iter129)
5944 mandeep.dh 9578 
      oprot.writeListEnd()
9579 
      oprot.writeFieldEnd()
9580 
    if self.cex is not None:
9581 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9582 
      self.cex.write(oprot)
9583 
      oprot.writeFieldEnd()
9584 
    oprot.writeFieldStop()
9585 
    oprot.writeStructEnd()
9586 
 
9587 
  def validate(self):
9588 
    return
9589 
 
9590 
 
9591 
  def __repr__(self):
9592 
    L = ['%s=%r' % (key, value)
9593 
      for key, value in self.__dict__.iteritems()]
9594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9595 
 
9596 
  def __eq__(self, other):
9597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9598 
 
9599 
  def __ne__(self, other):
9600 
    return not (self == other)
9601 
 
9602 
class getComingSoonCount_args:
9603 
 
9604 
  thrift_spec = (
9605 
  )
9606 
 
9607 
  def read(self, iprot):
9608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9610 
      return
9611 
    iprot.readStructBegin()
9612 
    while True:
9613 
      (fname, ftype, fid) = iprot.readFieldBegin()
9614 
      if ftype == TType.STOP:
9615 
        break
9616 
      else:
9617 
        iprot.skip(ftype)
9618 
      iprot.readFieldEnd()
9619 
    iprot.readStructEnd()
9620 
 
9621 
  def write(self, oprot):
9622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9624 
      return
9625 
    oprot.writeStructBegin('getComingSoonCount_args')
9626 
    oprot.writeFieldStop()
9627 
    oprot.writeStructEnd()
9628 
 
9629 
  def validate(self):
9630 
    return
9631 
 
9632 
 
9633 
  def __repr__(self):
9634 
    L = ['%s=%r' % (key, value)
9635 
      for key, value in self.__dict__.iteritems()]
9636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9637 
 
9638 
  def __eq__(self, other):
9639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9640 
 
9641 
  def __ne__(self, other):
9642 
    return not (self == other)
9643 
 
9644 
class getComingSoonCount_result:
9645 
  """
9646 
  Attributes:
9647 
   - success
9648 
   - cex
9649 
  """
9650 
 
9651 
  thrift_spec = (
9652 
    (0, TType.I64, 'success', None, None, ), # 0
9653 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9654 
  )
9655 
 
9656 
  def __init__(self, success=None, cex=None,):
9657 
    self.success = success
9658 
    self.cex = cex
9659 
 
9660 
  def read(self, iprot):
9661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9663 
      return
9664 
    iprot.readStructBegin()
9665 
    while True:
9666 
      (fname, ftype, fid) = iprot.readFieldBegin()
9667 
      if ftype == TType.STOP:
9668 
        break
9669 
      if fid == 0:
9670 
        if ftype == TType.I64:
9671 
          self.success = iprot.readI64();
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      elif fid == 1:
9675 
        if ftype == TType.STRUCT:
9676 
          self.cex = CatalogServiceException()
9677 
          self.cex.read(iprot)
9678 
        else:
9679 
          iprot.skip(ftype)
9680 
      else:
9681 
        iprot.skip(ftype)
9682 
      iprot.readFieldEnd()
9683 
    iprot.readStructEnd()
9684 
 
9685 
  def write(self, oprot):
9686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9688 
      return
9689 
    oprot.writeStructBegin('getComingSoonCount_result')
9690 
    if self.success is not None:
9691 
      oprot.writeFieldBegin('success', TType.I64, 0)
9692 
      oprot.writeI64(self.success)
9693 
      oprot.writeFieldEnd()
9694 
    if self.cex is not None:
9695 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9696 
      self.cex.write(oprot)
9697 
      oprot.writeFieldEnd()
9698 
    oprot.writeFieldStop()
9699 
    oprot.writeStructEnd()
9700 
 
9701 
  def validate(self):
9702 
    return
9703 
 
9704 
 
9705 
  def __repr__(self):
9706 
    L = ['%s=%r' % (key, value)
9707 
      for key, value in self.__dict__.iteritems()]
9708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9709 
 
9710 
  def __eq__(self, other):
9711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9712 
 
9713 
  def __ne__(self, other):
9714 
    return not (self == other)
9715 
 
9716 
class getLatestArrivals_args:
9717 
 
9718 
  thrift_spec = (
9719 
  )
9720 
 
9721 
  def read(self, iprot):
9722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9724 
      return
9725 
    iprot.readStructBegin()
9726 
    while True:
9727 
      (fname, ftype, fid) = iprot.readFieldBegin()
9728 
      if ftype == TType.STOP:
9729 
        break
9730 
      else:
9731 
        iprot.skip(ftype)
9732 
      iprot.readFieldEnd()
9733 
    iprot.readStructEnd()
9734 
 
9735 
  def write(self, oprot):
9736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9738 
      return
9739 
    oprot.writeStructBegin('getLatestArrivals_args')
9740 
    oprot.writeFieldStop()
9741 
    oprot.writeStructEnd()
9742 
 
9743 
  def validate(self):
9744 
    return
9745 
 
9746 
 
9747 
  def __repr__(self):
9748 
    L = ['%s=%r' % (key, value)
9749 
      for key, value in self.__dict__.iteritems()]
9750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9751 
 
9752 
  def __eq__(self, other):
9753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9754 
 
9755 
  def __ne__(self, other):
9756 
    return not (self == other)
9757 
 
9758 
class getLatestArrivals_result:
9759 
  """
9760 
  Attributes:
9761 
   - success
9762 
   - isex
9763 
  """
9764 
 
9765 
  thrift_spec = (
9766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9767 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9768 
  )
9769 
 
9770 
  def __init__(self, success=None, isex=None,):
9771 
    self.success = success
9772 
    self.isex = isex
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 == 0:
9784 
        if ftype == TType.LIST:
9785 
          self.success = []
8590 kshitij.so 9786 
          (_etype133, _size130) = iprot.readListBegin()
9787 
          for _i134 in xrange(_size130):
9788 
            _elem135 = Item()
9789 
            _elem135.read(iprot)
9790 
            self.success.append(_elem135)
5944 mandeep.dh 9791 
          iprot.readListEnd()
9792 
        else:
9793 
          iprot.skip(ftype)
9794 
      elif fid == 1:
9795 
        if ftype == TType.STRUCT:
9796 
          self.isex = CatalogServiceException()
9797 
          self.isex.read(iprot)
9798 
        else:
9799 
          iprot.skip(ftype)
9800 
      else:
9801 
        iprot.skip(ftype)
9802 
      iprot.readFieldEnd()
9803 
    iprot.readStructEnd()
9804 
 
9805 
  def write(self, oprot):
9806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9808 
      return
9809 
    oprot.writeStructBegin('getLatestArrivals_result')
9810 
    if self.success is not None:
9811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9812 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9813 
      for iter136 in self.success:
9814 
        iter136.write(oprot)
5944 mandeep.dh 9815 
      oprot.writeListEnd()
9816 
      oprot.writeFieldEnd()
9817 
    if self.isex is not None:
9818 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9819 
      self.isex.write(oprot)
9820 
      oprot.writeFieldEnd()
9821 
    oprot.writeFieldStop()
9822 
    oprot.writeStructEnd()
9823 
 
9824 
  def validate(self):
9825 
    return
9826 
 
9827 
 
9828 
  def __repr__(self):
9829 
    L = ['%s=%r' % (key, value)
9830 
      for key, value in self.__dict__.iteritems()]
9831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9832 
 
9833 
  def __eq__(self, other):
9834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9835 
 
9836 
  def __ne__(self, other):
9837 
    return not (self == other)
9838 
 
9839 
class getLatestArrivalsCatalogIds_args:
9840 
  """
9841 
  Attributes:
9842 
   - beginIndex
9843 
   - totalItems
9844 
   - brand
9845 
   - categories
9846 
  """
9847 
 
9848 
  thrift_spec = (
9849 
    None, # 0
9850 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9851 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9852 
    (3, TType.STRING, 'brand', None, None, ), # 3
9853 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9854 
  )
9855 
 
9856 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9857 
    self.beginIndex = beginIndex
9858 
    self.totalItems = totalItems
9859 
    self.brand = brand
9860 
    self.categories = categories
9861 
 
9862 
  def read(self, iprot):
9863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9865 
      return
9866 
    iprot.readStructBegin()
9867 
    while True:
9868 
      (fname, ftype, fid) = iprot.readFieldBegin()
9869 
      if ftype == TType.STOP:
9870 
        break
9871 
      if fid == 1:
9872 
        if ftype == TType.I64:
9873 
          self.beginIndex = iprot.readI64();
9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      elif fid == 2:
9877 
        if ftype == TType.I64:
9878 
          self.totalItems = iprot.readI64();
9879 
        else:
9880 
          iprot.skip(ftype)
9881 
      elif fid == 3:
9882 
        if ftype == TType.STRING:
9883 
          self.brand = iprot.readString();
9884 
        else:
9885 
          iprot.skip(ftype)
9886 
      elif fid == 4:
9887 
        if ftype == TType.LIST:
9888 
          self.categories = []
8590 kshitij.so 9889 
          (_etype140, _size137) = iprot.readListBegin()
9890 
          for _i141 in xrange(_size137):
9891 
            _elem142 = iprot.readI64();
9892 
            self.categories.append(_elem142)
5944 mandeep.dh 9893 
          iprot.readListEnd()
9894 
        else:
9895 
          iprot.skip(ftype)
9896 
      else:
9897 
        iprot.skip(ftype)
9898 
      iprot.readFieldEnd()
9899 
    iprot.readStructEnd()
9900 
 
9901 
  def write(self, oprot):
9902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9904 
      return
9905 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9906 
    if self.beginIndex is not None:
9907 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9908 
      oprot.writeI64(self.beginIndex)
9909 
      oprot.writeFieldEnd()
9910 
    if self.totalItems is not None:
9911 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9912 
      oprot.writeI64(self.totalItems)
9913 
      oprot.writeFieldEnd()
9914 
    if self.brand is not None:
9915 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9916 
      oprot.writeString(self.brand)
9917 
      oprot.writeFieldEnd()
9918 
    if self.categories is not None:
9919 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9920 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 9921 
      for iter143 in self.categories:
9922 
        oprot.writeI64(iter143)
5944 mandeep.dh 9923 
      oprot.writeListEnd()
9924 
      oprot.writeFieldEnd()
9925 
    oprot.writeFieldStop()
9926 
    oprot.writeStructEnd()
9927 
 
9928 
  def validate(self):
9929 
    return
9930 
 
9931 
 
9932 
  def __repr__(self):
9933 
    L = ['%s=%r' % (key, value)
9934 
      for key, value in self.__dict__.iteritems()]
9935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9936 
 
9937 
  def __eq__(self, other):
9938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9939 
 
9940 
  def __ne__(self, other):
9941 
    return not (self == other)
9942 
 
9943 
class getLatestArrivalsCatalogIds_result:
9944 
  """
9945 
  Attributes:
9946 
   - success
9947 
   - cex
9948 
  """
9949 
 
9950 
  thrift_spec = (
9951 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9952 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9953 
  )
9954 
 
9955 
  def __init__(self, success=None, cex=None,):
9956 
    self.success = success
9957 
    self.cex = cex
9958 
 
9959 
  def read(self, iprot):
9960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9962 
      return
9963 
    iprot.readStructBegin()
9964 
    while True:
9965 
      (fname, ftype, fid) = iprot.readFieldBegin()
9966 
      if ftype == TType.STOP:
9967 
        break
9968 
      if fid == 0:
9969 
        if ftype == TType.LIST:
9970 
          self.success = []
8590 kshitij.so 9971 
          (_etype147, _size144) = iprot.readListBegin()
9972 
          for _i148 in xrange(_size144):
9973 
            _elem149 = iprot.readI64();
9974 
            self.success.append(_elem149)
5944 mandeep.dh 9975 
          iprot.readListEnd()
9976 
        else:
9977 
          iprot.skip(ftype)
9978 
      elif fid == 1:
9979 
        if ftype == TType.STRUCT:
9980 
          self.cex = CatalogServiceException()
9981 
          self.cex.read(iprot)
9982 
        else:
9983 
          iprot.skip(ftype)
9984 
      else:
9985 
        iprot.skip(ftype)
9986 
      iprot.readFieldEnd()
9987 
    iprot.readStructEnd()
9988 
 
9989 
  def write(self, oprot):
9990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9992 
      return
9993 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9994 
    if self.success is not None:
9995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9996 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9997 
      for iter150 in self.success:
9998 
        oprot.writeI64(iter150)
5944 mandeep.dh 9999 
      oprot.writeListEnd()
10000 
      oprot.writeFieldEnd()
10001 
    if self.cex is not None:
10002 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10003 
      self.cex.write(oprot)
10004 
      oprot.writeFieldEnd()
10005 
    oprot.writeFieldStop()
10006 
    oprot.writeStructEnd()
10007 
 
10008 
  def validate(self):
10009 
    return
10010 
 
10011 
 
10012 
  def __repr__(self):
10013 
    L = ['%s=%r' % (key, value)
10014 
      for key, value in self.__dict__.iteritems()]
10015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10016 
 
10017 
  def __eq__(self, other):
10018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10019 
 
10020 
  def __ne__(self, other):
10021 
    return not (self == other)
10022 
 
10023 
class getLatestArrivalsCount_args:
10024 
 
10025 
  thrift_spec = (
10026 
  )
10027 
 
10028 
  def read(self, iprot):
10029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10031 
      return
10032 
    iprot.readStructBegin()
10033 
    while True:
10034 
      (fname, ftype, fid) = iprot.readFieldBegin()
10035 
      if ftype == TType.STOP:
10036 
        break
10037 
      else:
10038 
        iprot.skip(ftype)
10039 
      iprot.readFieldEnd()
10040 
    iprot.readStructEnd()
10041 
 
10042 
  def write(self, oprot):
10043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10045 
      return
10046 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10047 
    oprot.writeFieldStop()
10048 
    oprot.writeStructEnd()
10049 
 
10050 
  def validate(self):
10051 
    return
10052 
 
10053 
 
10054 
  def __repr__(self):
10055 
    L = ['%s=%r' % (key, value)
10056 
      for key, value in self.__dict__.iteritems()]
10057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10058 
 
10059 
  def __eq__(self, other):
10060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10061 
 
10062 
  def __ne__(self, other):
10063 
    return not (self == other)
10064 
 
10065 
class getLatestArrivalsCount_result:
10066 
  """
10067 
  Attributes:
10068 
   - success
10069 
   - cex
10070 
  """
10071 
 
10072 
  thrift_spec = (
10073 
    (0, TType.I64, 'success', None, None, ), # 0
10074 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10075 
  )
10076 
 
10077 
  def __init__(self, success=None, cex=None,):
10078 
    self.success = success
10079 
    self.cex = cex
10080 
 
10081 
  def read(self, iprot):
10082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10084 
      return
10085 
    iprot.readStructBegin()
10086 
    while True:
10087 
      (fname, ftype, fid) = iprot.readFieldBegin()
10088 
      if ftype == TType.STOP:
10089 
        break
10090 
      if fid == 0:
10091 
        if ftype == TType.I64:
10092 
          self.success = iprot.readI64();
10093 
        else:
10094 
          iprot.skip(ftype)
10095 
      elif fid == 1:
10096 
        if ftype == TType.STRUCT:
10097 
          self.cex = CatalogServiceException()
10098 
          self.cex.read(iprot)
10099 
        else:
10100 
          iprot.skip(ftype)
10101 
      else:
10102 
        iprot.skip(ftype)
10103 
      iprot.readFieldEnd()
10104 
    iprot.readStructEnd()
10105 
 
10106 
  def write(self, oprot):
10107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10109 
      return
10110 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10111 
    if self.success is not None:
10112 
      oprot.writeFieldBegin('success', TType.I64, 0)
10113 
      oprot.writeI64(self.success)
10114 
      oprot.writeFieldEnd()
10115 
    if self.cex is not None:
10116 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10117 
      self.cex.write(oprot)
10118 
      oprot.writeFieldEnd()
10119 
    oprot.writeFieldStop()
10120 
    oprot.writeStructEnd()
10121 
 
10122 
  def validate(self):
10123 
    return
10124 
 
10125 
 
10126 
  def __repr__(self):
10127 
    L = ['%s=%r' % (key, value)
10128 
      for key, value in self.__dict__.iteritems()]
10129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10130 
 
10131 
  def __eq__(self, other):
10132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10133 
 
10134 
  def __ne__(self, other):
10135 
    return not (self == other)
10136 
 
10137 
class generateNewEntityID_args:
10138 
 
10139 
  thrift_spec = (
10140 
  )
10141 
 
10142 
  def read(self, iprot):
10143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10145 
      return
10146 
    iprot.readStructBegin()
10147 
    while True:
10148 
      (fname, ftype, fid) = iprot.readFieldBegin()
10149 
      if ftype == TType.STOP:
10150 
        break
10151 
      else:
10152 
        iprot.skip(ftype)
10153 
      iprot.readFieldEnd()
10154 
    iprot.readStructEnd()
10155 
 
10156 
  def write(self, oprot):
10157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10159 
      return
10160 
    oprot.writeStructBegin('generateNewEntityID_args')
10161 
    oprot.writeFieldStop()
10162 
    oprot.writeStructEnd()
10163 
 
10164 
  def validate(self):
10165 
    return
10166 
 
10167 
 
10168 
  def __repr__(self):
10169 
    L = ['%s=%r' % (key, value)
10170 
      for key, value in self.__dict__.iteritems()]
10171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10172 
 
10173 
  def __eq__(self, other):
10174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10175 
 
10176 
  def __ne__(self, other):
10177 
    return not (self == other)
10178 
 
10179 
class generateNewEntityID_result:
10180 
  """
10181 
  Attributes:
10182 
   - success
10183 
  """
10184 
 
10185 
  thrift_spec = (
10186 
    (0, TType.I64, 'success', None, None, ), # 0
10187 
  )
10188 
 
10189 
  def __init__(self, success=None,):
10190 
    self.success = success
10191 
 
10192 
  def read(self, iprot):
10193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10195 
      return
10196 
    iprot.readStructBegin()
10197 
    while True:
10198 
      (fname, ftype, fid) = iprot.readFieldBegin()
10199 
      if ftype == TType.STOP:
10200 
        break
10201 
      if fid == 0:
10202 
        if ftype == TType.I64:
10203 
          self.success = iprot.readI64();
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      else:
10207 
        iprot.skip(ftype)
10208 
      iprot.readFieldEnd()
10209 
    iprot.readStructEnd()
10210 
 
10211 
  def write(self, oprot):
10212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10214 
      return
10215 
    oprot.writeStructBegin('generateNewEntityID_result')
10216 
    if self.success is not None:
10217 
      oprot.writeFieldBegin('success', TType.I64, 0)
10218 
      oprot.writeI64(self.success)
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 addCategory_args:
10239 
  """
10240 
  Attributes:
10241 
   - category
10242 
  """
10243 
 
10244 
  thrift_spec = (
10245 
    None, # 0
10246 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10247 
  )
10248 
 
10249 
  def __init__(self, category=None,):
10250 
    self.category = category
10251 
 
10252 
  def read(self, iprot):
10253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10255 
      return
10256 
    iprot.readStructBegin()
10257 
    while True:
10258 
      (fname, ftype, fid) = iprot.readFieldBegin()
10259 
      if ftype == TType.STOP:
10260 
        break
10261 
      if fid == 1:
10262 
        if ftype == TType.STRUCT:
10263 
          self.category = Category()
10264 
          self.category.read(iprot)
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      else:
10268 
        iprot.skip(ftype)
10269 
      iprot.readFieldEnd()
10270 
    iprot.readStructEnd()
10271 
 
10272 
  def write(self, oprot):
10273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10275 
      return
10276 
    oprot.writeStructBegin('addCategory_args')
10277 
    if self.category is not None:
10278 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10279 
      self.category.write(oprot)
10280 
      oprot.writeFieldEnd()
10281 
    oprot.writeFieldStop()
10282 
    oprot.writeStructEnd()
10283 
 
10284 
  def validate(self):
10285 
    return
10286 
 
10287 
 
10288 
  def __repr__(self):
10289 
    L = ['%s=%r' % (key, value)
10290 
      for key, value in self.__dict__.iteritems()]
10291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10292 
 
10293 
  def __eq__(self, other):
10294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10295 
 
10296 
  def __ne__(self, other):
10297 
    return not (self == other)
10298 
 
10299 
class addCategory_result:
10300 
  """
10301 
  Attributes:
10302 
   - success
10303 
  """
10304 
 
10305 
  thrift_spec = (
10306 
    (0, TType.BOOL, 'success', None, None, ), # 0
10307 
  )
10308 
 
10309 
  def __init__(self, success=None,):
10310 
    self.success = success
10311 
 
10312 
  def read(self, iprot):
10313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10315 
      return
10316 
    iprot.readStructBegin()
10317 
    while True:
10318 
      (fname, ftype, fid) = iprot.readFieldBegin()
10319 
      if ftype == TType.STOP:
10320 
        break
10321 
      if fid == 0:
10322 
        if ftype == TType.BOOL:
10323 
          self.success = iprot.readBool();
10324 
        else:
10325 
          iprot.skip(ftype)
10326 
      else:
10327 
        iprot.skip(ftype)
10328 
      iprot.readFieldEnd()
10329 
    iprot.readStructEnd()
10330 
 
10331 
  def write(self, oprot):
10332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10334 
      return
10335 
    oprot.writeStructBegin('addCategory_result')
10336 
    if self.success is not None:
10337 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10338 
      oprot.writeBool(self.success)
10339 
      oprot.writeFieldEnd()
10340 
    oprot.writeFieldStop()
10341 
    oprot.writeStructEnd()
10342 
 
10343 
  def validate(self):
10344 
    return
10345 
 
10346 
 
10347 
  def __repr__(self):
10348 
    L = ['%s=%r' % (key, value)
10349 
      for key, value in self.__dict__.iteritems()]
10350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10351 
 
10352 
  def __eq__(self, other):
10353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10354 
 
10355 
  def __ne__(self, other):
10356 
    return not (self == other)
10357 
 
10358 
class getCategory_args:
10359 
  """
10360 
  Attributes:
10361 
   - id
10362 
  """
10363 
 
10364 
  thrift_spec = (
10365 
    None, # 0
10366 
    (1, TType.I64, 'id', None, None, ), # 1
10367 
  )
10368 
 
10369 
  def __init__(self, id=None,):
10370 
    self.id = id
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 1:
10382 
        if ftype == TType.I64:
10383 
          self.id = iprot.readI64();
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      else:
10387 
        iprot.skip(ftype)
10388 
      iprot.readFieldEnd()
10389 
    iprot.readStructEnd()
10390 
 
10391 
  def write(self, oprot):
10392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10394 
      return
10395 
    oprot.writeStructBegin('getCategory_args')
10396 
    if self.id is not None:
10397 
      oprot.writeFieldBegin('id', TType.I64, 1)
10398 
      oprot.writeI64(self.id)
10399 
      oprot.writeFieldEnd()
10400 
    oprot.writeFieldStop()
10401 
    oprot.writeStructEnd()
10402 
 
10403 
  def validate(self):
10404 
    return
10405 
 
10406 
 
10407 
  def __repr__(self):
10408 
    L = ['%s=%r' % (key, value)
10409 
      for key, value in self.__dict__.iteritems()]
10410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10411 
 
10412 
  def __eq__(self, other):
10413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10414 
 
10415 
  def __ne__(self, other):
10416 
    return not (self == other)
10417 
 
10418 
class getCategory_result:
10419 
  """
10420 
  Attributes:
10421 
   - success
10422 
  """
10423 
 
10424 
  thrift_spec = (
10425 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10426 
  )
10427 
 
10428 
  def __init__(self, success=None,):
10429 
    self.success = success
10430 
 
10431 
  def read(self, iprot):
10432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10434 
      return
10435 
    iprot.readStructBegin()
10436 
    while True:
10437 
      (fname, ftype, fid) = iprot.readFieldBegin()
10438 
      if ftype == TType.STOP:
10439 
        break
10440 
      if fid == 0:
10441 
        if ftype == TType.STRUCT:
10442 
          self.success = Category()
10443 
          self.success.read(iprot)
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      else:
10447 
        iprot.skip(ftype)
10448 
      iprot.readFieldEnd()
10449 
    iprot.readStructEnd()
10450 
 
10451 
  def write(self, oprot):
10452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10454 
      return
10455 
    oprot.writeStructBegin('getCategory_result')
10456 
    if self.success is not None:
10457 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10458 
      self.success.write(oprot)
10459 
      oprot.writeFieldEnd()
10460 
    oprot.writeFieldStop()
10461 
    oprot.writeStructEnd()
10462 
 
10463 
  def validate(self):
10464 
    return
10465 
 
10466 
 
10467 
  def __repr__(self):
10468 
    L = ['%s=%r' % (key, value)
10469 
      for key, value in self.__dict__.iteritems()]
10470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10471 
 
10472 
  def __eq__(self, other):
10473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10474 
 
10475 
  def __ne__(self, other):
10476 
    return not (self == other)
10477 
 
10478 
class getAllCategories_args:
10479 
 
10480 
  thrift_spec = (
10481 
  )
10482 
 
10483 
  def read(self, iprot):
10484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10486 
      return
10487 
    iprot.readStructBegin()
10488 
    while True:
10489 
      (fname, ftype, fid) = iprot.readFieldBegin()
10490 
      if ftype == TType.STOP:
10491 
        break
10492 
      else:
10493 
        iprot.skip(ftype)
10494 
      iprot.readFieldEnd()
10495 
    iprot.readStructEnd()
10496 
 
10497 
  def write(self, oprot):
10498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10500 
      return
10501 
    oprot.writeStructBegin('getAllCategories_args')
10502 
    oprot.writeFieldStop()
10503 
    oprot.writeStructEnd()
10504 
 
10505 
  def validate(self):
10506 
    return
10507 
 
10508 
 
10509 
  def __repr__(self):
10510 
    L = ['%s=%r' % (key, value)
10511 
      for key, value in self.__dict__.iteritems()]
10512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10513 
 
10514 
  def __eq__(self, other):
10515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10516 
 
10517 
  def __ne__(self, other):
10518 
    return not (self == other)
10519 
 
10520 
class getAllCategories_result:
10521 
  """
10522 
  Attributes:
10523 
   - success
10524 
  """
10525 
 
10526 
  thrift_spec = (
10527 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10528 
  )
10529 
 
10530 
  def __init__(self, success=None,):
10531 
    self.success = success
10532 
 
10533 
  def read(self, iprot):
10534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10536 
      return
10537 
    iprot.readStructBegin()
10538 
    while True:
10539 
      (fname, ftype, fid) = iprot.readFieldBegin()
10540 
      if ftype == TType.STOP:
10541 
        break
10542 
      if fid == 0:
10543 
        if ftype == TType.LIST:
10544 
          self.success = []
8590 kshitij.so 10545 
          (_etype154, _size151) = iprot.readListBegin()
10546 
          for _i155 in xrange(_size151):
10547 
            _elem156 = Category()
10548 
            _elem156.read(iprot)
10549 
            self.success.append(_elem156)
5944 mandeep.dh 10550 
          iprot.readListEnd()
10551 
        else:
10552 
          iprot.skip(ftype)
10553 
      else:
10554 
        iprot.skip(ftype)
10555 
      iprot.readFieldEnd()
10556 
    iprot.readStructEnd()
10557 
 
10558 
  def write(self, oprot):
10559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10561 
      return
10562 
    oprot.writeStructBegin('getAllCategories_result')
10563 
    if self.success is not None:
10564 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10565 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10566 
      for iter157 in self.success:
10567 
        iter157.write(oprot)
5944 mandeep.dh 10568 
      oprot.writeListEnd()
10569 
      oprot.writeFieldEnd()
10570 
    oprot.writeFieldStop()
10571 
    oprot.writeStructEnd()
10572 
 
10573 
  def validate(self):
10574 
    return
10575 
 
10576 
 
10577 
  def __repr__(self):
10578 
    L = ['%s=%r' % (key, value)
10579 
      for key, value in self.__dict__.iteritems()]
10580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10581 
 
10582 
  def __eq__(self, other):
10583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10584 
 
10585 
  def __ne__(self, other):
10586 
    return not (self == other)
10587 
 
10588 
class getAllSimilarItems_args:
10589 
  """
10590 
  Attributes:
10591 
   - itemId
10592 
  """
10593 
 
10594 
  thrift_spec = (
10595 
    None, # 0
10596 
    (1, TType.I64, 'itemId', None, None, ), # 1
10597 
  )
10598 
 
10599 
  def __init__(self, itemId=None,):
10600 
    self.itemId = itemId
10601 
 
10602 
  def read(self, iprot):
10603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10605 
      return
10606 
    iprot.readStructBegin()
10607 
    while True:
10608 
      (fname, ftype, fid) = iprot.readFieldBegin()
10609 
      if ftype == TType.STOP:
10610 
        break
10611 
      if fid == 1:
10612 
        if ftype == TType.I64:
10613 
          self.itemId = iprot.readI64();
10614 
        else:
10615 
          iprot.skip(ftype)
10616 
      else:
10617 
        iprot.skip(ftype)
10618 
      iprot.readFieldEnd()
10619 
    iprot.readStructEnd()
10620 
 
10621 
  def write(self, oprot):
10622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10624 
      return
10625 
    oprot.writeStructBegin('getAllSimilarItems_args')
10626 
    if self.itemId is not None:
10627 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10628 
      oprot.writeI64(self.itemId)
10629 
      oprot.writeFieldEnd()
10630 
    oprot.writeFieldStop()
10631 
    oprot.writeStructEnd()
10632 
 
10633 
  def validate(self):
10634 
    return
10635 
 
10636 
 
10637 
  def __repr__(self):
10638 
    L = ['%s=%r' % (key, value)
10639 
      for key, value in self.__dict__.iteritems()]
10640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10641 
 
10642 
  def __eq__(self, other):
10643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10644 
 
10645 
  def __ne__(self, other):
10646 
    return not (self == other)
10647 
 
10648 
class getAllSimilarItems_result:
10649 
  """
10650 
  Attributes:
10651 
   - success
10652 
  """
10653 
 
10654 
  thrift_spec = (
10655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10656 
  )
10657 
 
10658 
  def __init__(self, success=None,):
10659 
    self.success = success
10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
10670 
      if fid == 0:
10671 
        if ftype == TType.LIST:
10672 
          self.success = []
8590 kshitij.so 10673 
          (_etype161, _size158) = iprot.readListBegin()
10674 
          for _i162 in xrange(_size158):
10675 
            _elem163 = Item()
10676 
            _elem163.read(iprot)
10677 
            self.success.append(_elem163)
5944 mandeep.dh 10678 
          iprot.readListEnd()
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      else:
10682 
        iprot.skip(ftype)
10683 
      iprot.readFieldEnd()
10684 
    iprot.readStructEnd()
10685 
 
10686 
  def write(self, oprot):
10687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10689 
      return
10690 
    oprot.writeStructBegin('getAllSimilarItems_result')
10691 
    if self.success is not None:
10692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10693 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10694 
      for iter164 in self.success:
10695 
        iter164.write(oprot)
5944 mandeep.dh 10696 
      oprot.writeListEnd()
10697 
      oprot.writeFieldEnd()
10698 
    oprot.writeFieldStop()
10699 
    oprot.writeStructEnd()
10700 
 
10701 
  def validate(self):
10702 
    return
10703 
 
10704 
 
10705 
  def __repr__(self):
10706 
    L = ['%s=%r' % (key, value)
10707 
      for key, value in self.__dict__.iteritems()]
10708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10709 
 
10710 
  def __eq__(self, other):
10711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10712 
 
10713 
  def __ne__(self, other):
10714 
    return not (self == other)
10715 
 
10716 
class addSimilarItem_args:
10717 
  """
10718 
  Attributes:
10719 
   - itemId
10720 
   - catalogItemId
10721 
  """
10722 
 
10723 
  thrift_spec = (
10724 
    None, # 0
10725 
    (1, TType.I64, 'itemId', None, None, ), # 1
10726 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10727 
  )
10728 
 
10729 
  def __init__(self, itemId=None, catalogItemId=None,):
10730 
    self.itemId = itemId
10731 
    self.catalogItemId = catalogItemId
10732 
 
10733 
  def read(self, iprot):
10734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10736 
      return
10737 
    iprot.readStructBegin()
10738 
    while True:
10739 
      (fname, ftype, fid) = iprot.readFieldBegin()
10740 
      if ftype == TType.STOP:
10741 
        break
10742 
      if fid == 1:
10743 
        if ftype == TType.I64:
10744 
          self.itemId = iprot.readI64();
10745 
        else:
10746 
          iprot.skip(ftype)
10747 
      elif fid == 2:
10748 
        if ftype == TType.I64:
10749 
          self.catalogItemId = iprot.readI64();
10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      else:
10753 
        iprot.skip(ftype)
10754 
      iprot.readFieldEnd()
10755 
    iprot.readStructEnd()
10756 
 
10757 
  def write(self, oprot):
10758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10760 
      return
10761 
    oprot.writeStructBegin('addSimilarItem_args')
10762 
    if self.itemId is not None:
10763 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10764 
      oprot.writeI64(self.itemId)
10765 
      oprot.writeFieldEnd()
10766 
    if self.catalogItemId is not None:
10767 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10768 
      oprot.writeI64(self.catalogItemId)
10769 
      oprot.writeFieldEnd()
10770 
    oprot.writeFieldStop()
10771 
    oprot.writeStructEnd()
10772 
 
10773 
  def validate(self):
10774 
    return
10775 
 
10776 
 
10777 
  def __repr__(self):
10778 
    L = ['%s=%r' % (key, value)
10779 
      for key, value in self.__dict__.iteritems()]
10780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10781 
 
10782 
  def __eq__(self, other):
10783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10784 
 
10785 
  def __ne__(self, other):
10786 
    return not (self == other)
10787 
 
10788 
class addSimilarItem_result:
10789 
  """
10790 
  Attributes:
10791 
   - success
10792 
   - cex
10793 
  """
10794 
 
10795 
  thrift_spec = (
10796 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10797 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10798 
  )
10799 
 
10800 
  def __init__(self, success=None, cex=None,):
10801 
    self.success = success
10802 
    self.cex = cex
10803 
 
10804 
  def read(self, iprot):
10805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10807 
      return
10808 
    iprot.readStructBegin()
10809 
    while True:
10810 
      (fname, ftype, fid) = iprot.readFieldBegin()
10811 
      if ftype == TType.STOP:
10812 
        break
10813 
      if fid == 0:
10814 
        if ftype == TType.STRUCT:
10815 
          self.success = Item()
10816 
          self.success.read(iprot)
10817 
        else:
10818 
          iprot.skip(ftype)
10819 
      elif fid == 1:
10820 
        if ftype == TType.STRUCT:
10821 
          self.cex = CatalogServiceException()
10822 
          self.cex.read(iprot)
10823 
        else:
10824 
          iprot.skip(ftype)
10825 
      else:
10826 
        iprot.skip(ftype)
10827 
      iprot.readFieldEnd()
10828 
    iprot.readStructEnd()
10829 
 
10830 
  def write(self, oprot):
10831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10833 
      return
10834 
    oprot.writeStructBegin('addSimilarItem_result')
10835 
    if self.success is not None:
10836 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10837 
      self.success.write(oprot)
10838 
      oprot.writeFieldEnd()
10839 
    if self.cex is not None:
10840 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10841 
      self.cex.write(oprot)
10842 
      oprot.writeFieldEnd()
10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
10846 
  def validate(self):
10847 
    return
10848 
 
10849 
 
10850 
  def __repr__(self):
10851 
    L = ['%s=%r' % (key, value)
10852 
      for key, value in self.__dict__.iteritems()]
10853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10854 
 
10855 
  def __eq__(self, other):
10856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10857 
 
10858 
  def __ne__(self, other):
10859 
    return not (self == other)
10860 
 
6512 kshitij.so 10861 
class addTag_args:
10862 
  """
10863 
  Attributes:
10864 
   - displayName
10865 
   - itemId
10866 
  """
10867 
 
10868 
  thrift_spec = (
10869 
    None, # 0
10870 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10871 
    (2, TType.I64, 'itemId', None, None, ), # 2
10872 
  )
10873 
 
10874 
  def __init__(self, displayName=None, itemId=None,):
10875 
    self.displayName = displayName
10876 
    self.itemId = itemId
10877 
 
10878 
  def read(self, iprot):
10879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10881 
      return
10882 
    iprot.readStructBegin()
10883 
    while True:
10884 
      (fname, ftype, fid) = iprot.readFieldBegin()
10885 
      if ftype == TType.STOP:
10886 
        break
10887 
      if fid == 1:
10888 
        if ftype == TType.STRING:
10889 
          self.displayName = iprot.readString();
10890 
        else:
10891 
          iprot.skip(ftype)
10892 
      elif fid == 2:
10893 
        if ftype == TType.I64:
10894 
          self.itemId = iprot.readI64();
10895 
        else:
10896 
          iprot.skip(ftype)
10897 
      else:
10898 
        iprot.skip(ftype)
10899 
      iprot.readFieldEnd()
10900 
    iprot.readStructEnd()
10901 
 
10902 
  def write(self, oprot):
10903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10905 
      return
10906 
    oprot.writeStructBegin('addTag_args')
10907 
    if self.displayName is not None:
10908 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10909 
      oprot.writeString(self.displayName)
10910 
      oprot.writeFieldEnd()
10911 
    if self.itemId is not None:
10912 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10913 
      oprot.writeI64(self.itemId)
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 addTag_result:
10934 
  """
10935 
  Attributes:
10936 
   - success
10937 
  """
10938 
 
10939 
  thrift_spec = (
10940 
    (0, TType.BOOL, 'success', 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.BOOL:
10957 
          self.success = iprot.readBool();
10958 
        else:
10959 
          iprot.skip(ftype)
10960 
      else:
10961 
        iprot.skip(ftype)
10962 
      iprot.readFieldEnd()
10963 
    iprot.readStructEnd()
10964 
 
10965 
  def write(self, oprot):
10966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10968 
      return
10969 
    oprot.writeStructBegin('addTag_result')
10970 
    if self.success is not None:
10971 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10972 
      oprot.writeBool(self.success)
10973 
      oprot.writeFieldEnd()
10974 
    oprot.writeFieldStop()
10975 
    oprot.writeStructEnd()
10976 
 
10977 
  def validate(self):
10978 
    return
10979 
 
10980 
 
10981 
  def __repr__(self):
10982 
    L = ['%s=%r' % (key, value)
10983 
      for key, value in self.__dict__.iteritems()]
10984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10985 
 
10986 
  def __eq__(self, other):
10987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10988 
 
10989 
  def __ne__(self, other):
10990 
    return not (self == other)
10991 
 
10992 
class deleteEntityTag_args:
10993 
  """
10994 
  Attributes:
10995 
   - displayName
10996 
   - itemId
10997 
  """
10998 
 
10999 
  thrift_spec = (
11000 
    None, # 0
11001 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11002 
    (2, TType.I64, 'itemId', None, None, ), # 2
11003 
  )
11004 
 
11005 
  def __init__(self, displayName=None, itemId=None,):
11006 
    self.displayName = displayName
11007 
    self.itemId = itemId
11008 
 
11009 
  def read(self, iprot):
11010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11012 
      return
11013 
    iprot.readStructBegin()
11014 
    while True:
11015 
      (fname, ftype, fid) = iprot.readFieldBegin()
11016 
      if ftype == TType.STOP:
11017 
        break
11018 
      if fid == 1:
11019 
        if ftype == TType.STRING:
11020 
          self.displayName = iprot.readString();
11021 
        else:
11022 
          iprot.skip(ftype)
11023 
      elif fid == 2:
11024 
        if ftype == TType.I64:
11025 
          self.itemId = iprot.readI64();
11026 
        else:
11027 
          iprot.skip(ftype)
11028 
      else:
11029 
        iprot.skip(ftype)
11030 
      iprot.readFieldEnd()
11031 
    iprot.readStructEnd()
11032 
 
11033 
  def write(self, oprot):
11034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11036 
      return
11037 
    oprot.writeStructBegin('deleteEntityTag_args')
11038 
    if self.displayName is not None:
11039 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11040 
      oprot.writeString(self.displayName)
11041 
      oprot.writeFieldEnd()
11042 
    if self.itemId is not None:
11043 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11044 
      oprot.writeI64(self.itemId)
11045 
      oprot.writeFieldEnd()
11046 
    oprot.writeFieldStop()
11047 
    oprot.writeStructEnd()
11048 
 
11049 
  def validate(self):
11050 
    return
11051 
 
11052 
 
11053 
  def __repr__(self):
11054 
    L = ['%s=%r' % (key, value)
11055 
      for key, value in self.__dict__.iteritems()]
11056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11057 
 
11058 
  def __eq__(self, other):
11059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11060 
 
11061 
  def __ne__(self, other):
11062 
    return not (self == other)
11063 
 
11064 
class deleteEntityTag_result:
11065 
  """
11066 
  Attributes:
11067 
   - success
11068 
  """
11069 
 
11070 
  thrift_spec = (
11071 
    (0, TType.BOOL, 'success', None, None, ), # 0
11072 
  )
11073 
 
11074 
  def __init__(self, success=None,):
11075 
    self.success = success
11076 
 
11077 
  def read(self, iprot):
11078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11080 
      return
11081 
    iprot.readStructBegin()
11082 
    while True:
11083 
      (fname, ftype, fid) = iprot.readFieldBegin()
11084 
      if ftype == TType.STOP:
11085 
        break
11086 
      if fid == 0:
11087 
        if ftype == TType.BOOL:
11088 
          self.success = iprot.readBool();
11089 
        else:
11090 
          iprot.skip(ftype)
11091 
      else:
11092 
        iprot.skip(ftype)
11093 
      iprot.readFieldEnd()
11094 
    iprot.readStructEnd()
11095 
 
11096 
  def write(self, oprot):
11097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11099 
      return
11100 
    oprot.writeStructBegin('deleteEntityTag_result')
11101 
    if self.success is not None:
11102 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11103 
      oprot.writeBool(self.success)
11104 
      oprot.writeFieldEnd()
11105 
    oprot.writeFieldStop()
11106 
    oprot.writeStructEnd()
11107 
 
11108 
  def validate(self):
11109 
    return
11110 
 
11111 
 
11112 
  def __repr__(self):
11113 
    L = ['%s=%r' % (key, value)
11114 
      for key, value in self.__dict__.iteritems()]
11115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11116 
 
11117 
  def __eq__(self, other):
11118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11119 
 
11120 
  def __ne__(self, other):
11121 
    return not (self == other)
11122 
 
11123 
class deleteTag_args:
11124 
  """
11125 
  Attributes:
11126 
   - displayName
11127 
  """
11128 
 
11129 
  thrift_spec = (
11130 
    None, # 0
11131 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11132 
  )
11133 
 
11134 
  def __init__(self, displayName=None,):
11135 
    self.displayName = displayName
11136 
 
11137 
  def read(self, iprot):
11138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11140 
      return
11141 
    iprot.readStructBegin()
11142 
    while True:
11143 
      (fname, ftype, fid) = iprot.readFieldBegin()
11144 
      if ftype == TType.STOP:
11145 
        break
11146 
      if fid == 1:
11147 
        if ftype == TType.STRING:
11148 
          self.displayName = iprot.readString();
11149 
        else:
11150 
          iprot.skip(ftype)
11151 
      else:
11152 
        iprot.skip(ftype)
11153 
      iprot.readFieldEnd()
11154 
    iprot.readStructEnd()
11155 
 
11156 
  def write(self, oprot):
11157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11159 
      return
11160 
    oprot.writeStructBegin('deleteTag_args')
11161 
    if self.displayName is not None:
11162 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11163 
      oprot.writeString(self.displayName)
11164 
      oprot.writeFieldEnd()
11165 
    oprot.writeFieldStop()
11166 
    oprot.writeStructEnd()
11167 
 
11168 
  def validate(self):
11169 
    return
11170 
 
11171 
 
11172 
  def __repr__(self):
11173 
    L = ['%s=%r' % (key, value)
11174 
      for key, value in self.__dict__.iteritems()]
11175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11176 
 
11177 
  def __eq__(self, other):
11178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11179 
 
11180 
  def __ne__(self, other):
11181 
    return not (self == other)
11182 
 
11183 
class deleteTag_result:
11184 
  """
11185 
  Attributes:
11186 
   - success
11187 
  """
11188 
 
11189 
  thrift_spec = (
11190 
    (0, TType.BOOL, 'success', None, None, ), # 0
11191 
  )
11192 
 
11193 
  def __init__(self, success=None,):
11194 
    self.success = success
11195 
 
11196 
  def read(self, iprot):
11197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11199 
      return
11200 
    iprot.readStructBegin()
11201 
    while True:
11202 
      (fname, ftype, fid) = iprot.readFieldBegin()
11203 
      if ftype == TType.STOP:
11204 
        break
11205 
      if fid == 0:
11206 
        if ftype == TType.BOOL:
11207 
          self.success = iprot.readBool();
11208 
        else:
11209 
          iprot.skip(ftype)
11210 
      else:
11211 
        iprot.skip(ftype)
11212 
      iprot.readFieldEnd()
11213 
    iprot.readStructEnd()
11214 
 
11215 
  def write(self, oprot):
11216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11218 
      return
11219 
    oprot.writeStructBegin('deleteTag_result')
11220 
    if self.success is not None:
11221 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11222 
      oprot.writeBool(self.success)
11223 
      oprot.writeFieldEnd()
11224 
    oprot.writeFieldStop()
11225 
    oprot.writeStructEnd()
11226 
 
11227 
  def validate(self):
11228 
    return
11229 
 
11230 
 
11231 
  def __repr__(self):
11232 
    L = ['%s=%r' % (key, value)
11233 
      for key, value in self.__dict__.iteritems()]
11234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11235 
 
11236 
  def __eq__(self, other):
11237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11238 
 
11239 
  def __ne__(self, other):
11240 
    return not (self == other)
11241 
 
11242 
class getAllTags_args:
11243 
 
11244 
  thrift_spec = (
11245 
  )
11246 
 
11247 
  def read(self, iprot):
11248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11250 
      return
11251 
    iprot.readStructBegin()
11252 
    while True:
11253 
      (fname, ftype, fid) = iprot.readFieldBegin()
11254 
      if ftype == TType.STOP:
11255 
        break
11256 
      else:
11257 
        iprot.skip(ftype)
11258 
      iprot.readFieldEnd()
11259 
    iprot.readStructEnd()
11260 
 
11261 
  def write(self, oprot):
11262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11264 
      return
11265 
    oprot.writeStructBegin('getAllTags_args')
11266 
    oprot.writeFieldStop()
11267 
    oprot.writeStructEnd()
11268 
 
11269 
  def validate(self):
11270 
    return
11271 
 
11272 
 
11273 
  def __repr__(self):
11274 
    L = ['%s=%r' % (key, value)
11275 
      for key, value in self.__dict__.iteritems()]
11276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11277 
 
11278 
  def __eq__(self, other):
11279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11280 
 
11281 
  def __ne__(self, other):
11282 
    return not (self == other)
11283 
 
11284 
class getAllTags_result:
11285 
  """
11286 
  Attributes:
11287 
   - success
11288 
  """
11289 
 
11290 
  thrift_spec = (
11291 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11292 
  )
11293 
 
11294 
  def __init__(self, success=None,):
11295 
    self.success = success
11296 
 
11297 
  def read(self, iprot):
11298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11300 
      return
11301 
    iprot.readStructBegin()
11302 
    while True:
11303 
      (fname, ftype, fid) = iprot.readFieldBegin()
11304 
      if ftype == TType.STOP:
11305 
        break
11306 
      if fid == 0:
11307 
        if ftype == TType.LIST:
11308 
          self.success = []
8590 kshitij.so 11309 
          (_etype168, _size165) = iprot.readListBegin()
11310 
          for _i169 in xrange(_size165):
11311 
            _elem170 = iprot.readString();
11312 
            self.success.append(_elem170)
6512 kshitij.so 11313 
          iprot.readListEnd()
11314 
        else:
11315 
          iprot.skip(ftype)
11316 
      else:
11317 
        iprot.skip(ftype)
11318 
      iprot.readFieldEnd()
11319 
    iprot.readStructEnd()
11320 
 
11321 
  def write(self, oprot):
11322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11324 
      return
11325 
    oprot.writeStructBegin('getAllTags_result')
11326 
    if self.success is not None:
11327 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11328 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11329 
      for iter171 in self.success:
11330 
        oprot.writeString(iter171)
6512 kshitij.so 11331 
      oprot.writeListEnd()
11332 
      oprot.writeFieldEnd()
11333 
    oprot.writeFieldStop()
11334 
    oprot.writeStructEnd()
11335 
 
11336 
  def validate(self):
11337 
    return
11338 
 
11339 
 
11340 
  def __repr__(self):
11341 
    L = ['%s=%r' % (key, value)
11342 
      for key, value in self.__dict__.iteritems()]
11343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11344 
 
11345 
  def __eq__(self, other):
11346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11347 
 
11348 
  def __ne__(self, other):
11349 
    return not (self == other)
11350 
 
11351 
class getAllEntitiesByTagName_args:
11352 
  """
11353 
  Attributes:
11354 
   - displayName
11355 
  """
11356 
 
11357 
  thrift_spec = (
11358 
    None, # 0
11359 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11360 
  )
11361 
 
11362 
  def __init__(self, displayName=None,):
11363 
    self.displayName = displayName
11364 
 
11365 
  def read(self, iprot):
11366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11368 
      return
11369 
    iprot.readStructBegin()
11370 
    while True:
11371 
      (fname, ftype, fid) = iprot.readFieldBegin()
11372 
      if ftype == TType.STOP:
11373 
        break
11374 
      if fid == 1:
11375 
        if ftype == TType.STRING:
11376 
          self.displayName = iprot.readString();
11377 
        else:
11378 
          iprot.skip(ftype)
11379 
      else:
11380 
        iprot.skip(ftype)
11381 
      iprot.readFieldEnd()
11382 
    iprot.readStructEnd()
11383 
 
11384 
  def write(self, oprot):
11385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11387 
      return
11388 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11389 
    if self.displayName is not None:
11390 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11391 
      oprot.writeString(self.displayName)
11392 
      oprot.writeFieldEnd()
11393 
    oprot.writeFieldStop()
11394 
    oprot.writeStructEnd()
11395 
 
11396 
  def validate(self):
11397 
    return
11398 
 
11399 
 
11400 
  def __repr__(self):
11401 
    L = ['%s=%r' % (key, value)
11402 
      for key, value in self.__dict__.iteritems()]
11403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11404 
 
11405 
  def __eq__(self, other):
11406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11407 
 
11408 
  def __ne__(self, other):
11409 
    return not (self == other)
11410 
 
11411 
class getAllEntitiesByTagName_result:
11412 
  """
11413 
  Attributes:
11414 
   - success
11415 
  """
11416 
 
11417 
  thrift_spec = (
11418 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11419 
  )
11420 
 
11421 
  def __init__(self, success=None,):
11422 
    self.success = success
11423 
 
11424 
  def read(self, iprot):
11425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11427 
      return
11428 
    iprot.readStructBegin()
11429 
    while True:
11430 
      (fname, ftype, fid) = iprot.readFieldBegin()
11431 
      if ftype == TType.STOP:
11432 
        break
11433 
      if fid == 0:
11434 
        if ftype == TType.LIST:
11435 
          self.success = []
8590 kshitij.so 11436 
          (_etype175, _size172) = iprot.readListBegin()
11437 
          for _i176 in xrange(_size172):
11438 
            _elem177 = iprot.readI64();
11439 
            self.success.append(_elem177)
6512 kshitij.so 11440 
          iprot.readListEnd()
11441 
        else:
11442 
          iprot.skip(ftype)
11443 
      else:
11444 
        iprot.skip(ftype)
11445 
      iprot.readFieldEnd()
11446 
    iprot.readStructEnd()
11447 
 
11448 
  def write(self, oprot):
11449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11451 
      return
11452 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
11453 
    if self.success is not None:
11454 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11455 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11456 
      for iter178 in self.success:
11457 
        oprot.writeI64(iter178)
6512 kshitij.so 11458 
      oprot.writeListEnd()
11459 
      oprot.writeFieldEnd()
11460 
    oprot.writeFieldStop()
11461 
    oprot.writeStructEnd()
11462 
 
11463 
  def validate(self):
11464 
    return
11465 
 
11466 
 
11467 
  def __repr__(self):
11468 
    L = ['%s=%r' % (key, value)
11469 
      for key, value in self.__dict__.iteritems()]
11470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11471 
 
11472 
  def __eq__(self, other):
11473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11474 
 
11475 
  def __ne__(self, other):
11476 
    return not (self == other)
11477 
 
6845 amit.gupta 11478 
class getAllEntityTags_args:
11479 
 
11480 
  thrift_spec = (
11481 
  )
11482 
 
11483 
  def read(self, iprot):
11484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11486 
      return
11487 
    iprot.readStructBegin()
11488 
    while True:
11489 
      (fname, ftype, fid) = iprot.readFieldBegin()
11490 
      if ftype == TType.STOP:
11491 
        break
11492 
      else:
11493 
        iprot.skip(ftype)
11494 
      iprot.readFieldEnd()
11495 
    iprot.readStructEnd()
11496 
 
11497 
  def write(self, oprot):
11498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11500 
      return
11501 
    oprot.writeStructBegin('getAllEntityTags_args')
11502 
    oprot.writeFieldStop()
11503 
    oprot.writeStructEnd()
11504 
 
11505 
  def validate(self):
11506 
    return
11507 
 
11508 
 
11509 
  def __repr__(self):
11510 
    L = ['%s=%r' % (key, value)
11511 
      for key, value in self.__dict__.iteritems()]
11512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11513 
 
11514 
  def __eq__(self, other):
11515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11516 
 
11517 
  def __ne__(self, other):
11518 
    return not (self == other)
11519 
 
11520 
class getAllEntityTags_result:
11521 
  """
11522 
  Attributes:
11523 
   - success
11524 
  """
11525 
 
11526 
  thrift_spec = (
11527 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11528 
  )
11529 
 
11530 
  def __init__(self, success=None,):
11531 
    self.success = success
11532 
 
11533 
  def read(self, iprot):
11534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11536 
      return
11537 
    iprot.readStructBegin()
11538 
    while True:
11539 
      (fname, ftype, fid) = iprot.readFieldBegin()
11540 
      if ftype == TType.STOP:
11541 
        break
11542 
      if fid == 0:
11543 
        if ftype == TType.MAP:
11544 
          self.success = {}
8590 kshitij.so 11545 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
11546 
          for _i183 in xrange(_size179):
11547 
            _key184 = iprot.readI64();
11548 
            _val185 = []
11549 
            (_etype189, _size186) = iprot.readListBegin()
11550 
            for _i190 in xrange(_size186):
11551 
              _elem191 = iprot.readString();
11552 
              _val185.append(_elem191)
6845 amit.gupta 11553 
            iprot.readListEnd()
8590 kshitij.so 11554 
            self.success[_key184] = _val185
6845 amit.gupta 11555 
          iprot.readMapEnd()
11556 
        else:
11557 
          iprot.skip(ftype)
11558 
      else:
11559 
        iprot.skip(ftype)
11560 
      iprot.readFieldEnd()
11561 
    iprot.readStructEnd()
11562 
 
11563 
  def write(self, oprot):
11564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11566 
      return
11567 
    oprot.writeStructBegin('getAllEntityTags_result')
11568 
    if self.success is not None:
11569 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11570 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 11571 
      for kiter192,viter193 in self.success.items():
11572 
        oprot.writeI64(kiter192)
11573 
        oprot.writeListBegin(TType.STRING, len(viter193))
11574 
        for iter194 in viter193:
11575 
          oprot.writeString(iter194)
6845 amit.gupta 11576 
        oprot.writeListEnd()
11577 
      oprot.writeMapEnd()
11578 
      oprot.writeFieldEnd()
11579 
    oprot.writeFieldStop()
11580 
    oprot.writeStructEnd()
11581 
 
11582 
  def validate(self):
11583 
    return
11584 
 
11585 
 
11586 
  def __repr__(self):
11587 
    L = ['%s=%r' % (key, value)
11588 
      for key, value in self.__dict__.iteritems()]
11589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11590 
 
11591 
  def __eq__(self, other):
11592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11593 
 
11594 
  def __ne__(self, other):
11595 
    return not (self == other)
11596 
 
6850 kshitij.so 11597 
class addBanner_args:
11598 
  """
11599 
  Attributes:
8590 kshitij.so 11600 
   - bannerCongregate
6850 kshitij.so 11601 
  """
11602 
 
11603 
  thrift_spec = (
11604 
    None, # 0
8590 kshitij.so 11605 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 11606 
  )
11607 
 
8590 kshitij.so 11608 
  def __init__(self, bannerCongregate=None,):
11609 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 11610 
 
11611 
  def read(self, iprot):
11612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11614 
      return
11615 
    iprot.readStructBegin()
11616 
    while True:
11617 
      (fname, ftype, fid) = iprot.readFieldBegin()
11618 
      if ftype == TType.STOP:
11619 
        break
11620 
      if fid == 1:
8579 kshitij.so 11621 
        if ftype == TType.STRUCT:
8590 kshitij.so 11622 
          self.bannerCongregate = BannerCongregate()
11623 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 11624 
        else:
11625 
          iprot.skip(ftype)
8579 kshitij.so 11626 
      else:
11627 
        iprot.skip(ftype)
11628 
      iprot.readFieldEnd()
11629 
    iprot.readStructEnd()
11630 
 
11631 
  def write(self, oprot):
11632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11634 
      return
11635 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 11636 
    if self.bannerCongregate is not None:
11637 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
11638 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 11639 
      oprot.writeFieldEnd()
11640 
    oprot.writeFieldStop()
11641 
    oprot.writeStructEnd()
11642 
 
11643 
  def validate(self):
11644 
    return
11645 
 
11646 
 
11647 
  def __repr__(self):
11648 
    L = ['%s=%r' % (key, value)
11649 
      for key, value in self.__dict__.iteritems()]
11650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11651 
 
11652 
  def __eq__(self, other):
11653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11654 
 
11655 
  def __ne__(self, other):
11656 
    return not (self == other)
11657 
 
11658 
class addBanner_result:
11659 
 
11660 
  thrift_spec = (
11661 
  )
11662 
 
11663 
  def read(self, iprot):
11664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11666 
      return
11667 
    iprot.readStructBegin()
11668 
    while True:
11669 
      (fname, ftype, fid) = iprot.readFieldBegin()
11670 
      if ftype == TType.STOP:
11671 
        break
11672 
      else:
11673 
        iprot.skip(ftype)
11674 
      iprot.readFieldEnd()
11675 
    iprot.readStructEnd()
11676 
 
11677 
  def write(self, oprot):
11678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11680 
      return
11681 
    oprot.writeStructBegin('addBanner_result')
11682 
    oprot.writeFieldStop()
11683 
    oprot.writeStructEnd()
11684 
 
11685 
  def validate(self):
11686 
    return
11687 
 
11688 
 
11689 
  def __repr__(self):
11690 
    L = ['%s=%r' % (key, value)
11691 
      for key, value in self.__dict__.iteritems()]
11692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11693 
 
11694 
  def __eq__(self, other):
11695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11696 
 
11697 
  def __ne__(self, other):
11698 
    return not (self == other)
11699 
 
11700 
class updateBanner_args:
11701 
  """
11702 
  Attributes:
11703 
   - banner
11704 
  """
11705 
 
11706 
  thrift_spec = (
11707 
    None, # 0
11708 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
11709 
  )
11710 
 
11711 
  def __init__(self, banner=None,):
11712 
    self.banner = banner
11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
11723 
      if fid == 1:
11724 
        if ftype == TType.STRUCT:
11725 
          self.banner = Banner()
11726 
          self.banner.read(iprot)
6850 kshitij.so 11727 
        else:
11728 
          iprot.skip(ftype)
11729 
      else:
11730 
        iprot.skip(ftype)
11731 
      iprot.readFieldEnd()
11732 
    iprot.readStructEnd()
11733 
 
11734 
  def write(self, oprot):
11735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11737 
      return
8579 kshitij.so 11738 
    oprot.writeStructBegin('updateBanner_args')
11739 
    if self.banner is not None:
11740 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
11741 
      self.banner.write(oprot)
6850 kshitij.so 11742 
      oprot.writeFieldEnd()
11743 
    oprot.writeFieldStop()
11744 
    oprot.writeStructEnd()
11745 
 
11746 
  def validate(self):
11747 
    return
11748 
 
11749 
 
11750 
  def __repr__(self):
11751 
    L = ['%s=%r' % (key, value)
11752 
      for key, value in self.__dict__.iteritems()]
11753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11754 
 
11755 
  def __eq__(self, other):
11756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11757 
 
11758 
  def __ne__(self, other):
11759 
    return not (self == other)
11760 
 
8579 kshitij.so 11761 
class updateBanner_result:
6850 kshitij.so 11762 
  """
11763 
  Attributes:
11764 
   - success
11765 
  """
11766 
 
11767 
  thrift_spec = (
11768 
    (0, TType.BOOL, 'success', None, None, ), # 0
11769 
  )
11770 
 
11771 
  def __init__(self, success=None,):
11772 
    self.success = success
11773 
 
11774 
  def read(self, iprot):
11775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11777 
      return
11778 
    iprot.readStructBegin()
11779 
    while True:
11780 
      (fname, ftype, fid) = iprot.readFieldBegin()
11781 
      if ftype == TType.STOP:
11782 
        break
11783 
      if fid == 0:
11784 
        if ftype == TType.BOOL:
11785 
          self.success = iprot.readBool();
11786 
        else:
11787 
          iprot.skip(ftype)
11788 
      else:
11789 
        iprot.skip(ftype)
11790 
      iprot.readFieldEnd()
11791 
    iprot.readStructEnd()
11792 
 
11793 
  def write(self, oprot):
11794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11796 
      return
8579 kshitij.so 11797 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 11798 
    if self.success is not None:
11799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11800 
      oprot.writeBool(self.success)
11801 
      oprot.writeFieldEnd()
11802 
    oprot.writeFieldStop()
11803 
    oprot.writeStructEnd()
11804 
 
11805 
  def validate(self):
11806 
    return
11807 
 
11808 
 
11809 
  def __repr__(self):
11810 
    L = ['%s=%r' % (key, value)
11811 
      for key, value in self.__dict__.iteritems()]
11812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11813 
 
11814 
  def __eq__(self, other):
11815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11816 
 
11817 
  def __ne__(self, other):
11818 
    return not (self == other)
11819 
 
11820 
class getAllBanners_args:
11821 
 
11822 
  thrift_spec = (
11823 
  )
11824 
 
11825 
  def read(self, iprot):
11826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11828 
      return
11829 
    iprot.readStructBegin()
11830 
    while True:
11831 
      (fname, ftype, fid) = iprot.readFieldBegin()
11832 
      if ftype == TType.STOP:
11833 
        break
11834 
      else:
11835 
        iprot.skip(ftype)
11836 
      iprot.readFieldEnd()
11837 
    iprot.readStructEnd()
11838 
 
11839 
  def write(self, oprot):
11840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11842 
      return
11843 
    oprot.writeStructBegin('getAllBanners_args')
11844 
    oprot.writeFieldStop()
11845 
    oprot.writeStructEnd()
11846 
 
11847 
  def validate(self):
11848 
    return
11849 
 
11850 
 
11851 
  def __repr__(self):
11852 
    L = ['%s=%r' % (key, value)
11853 
      for key, value in self.__dict__.iteritems()]
11854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11855 
 
11856 
  def __eq__(self, other):
11857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11858 
 
11859 
  def __ne__(self, other):
11860 
    return not (self == other)
11861 
 
11862 
class getAllBanners_result:
11863 
  """
11864 
  Attributes:
11865 
   - success
11866 
  """
11867 
 
11868 
  thrift_spec = (
8579 kshitij.so 11869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 11870 
  )
11871 
 
11872 
  def __init__(self, success=None,):
11873 
    self.success = success
11874 
 
11875 
  def read(self, iprot):
11876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11878 
      return
11879 
    iprot.readStructBegin()
11880 
    while True:
11881 
      (fname, ftype, fid) = iprot.readFieldBegin()
11882 
      if ftype == TType.STOP:
11883 
        break
11884 
      if fid == 0:
11885 
        if ftype == TType.LIST:
11886 
          self.success = []
8590 kshitij.so 11887 
          (_etype198, _size195) = iprot.readListBegin()
11888 
          for _i199 in xrange(_size195):
11889 
            _elem200 = Banner()
11890 
            _elem200.read(iprot)
11891 
            self.success.append(_elem200)
6850 kshitij.so 11892 
          iprot.readListEnd()
11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      else:
11896 
        iprot.skip(ftype)
11897 
      iprot.readFieldEnd()
11898 
    iprot.readStructEnd()
11899 
 
11900 
  def write(self, oprot):
11901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11903 
      return
11904 
    oprot.writeStructBegin('getAllBanners_result')
11905 
    if self.success is not None:
11906 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 11907 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11908 
      for iter201 in self.success:
11909 
        iter201.write(oprot)
6850 kshitij.so 11910 
      oprot.writeListEnd()
11911 
      oprot.writeFieldEnd()
11912 
    oprot.writeFieldStop()
11913 
    oprot.writeStructEnd()
11914 
 
11915 
  def validate(self):
11916 
    return
11917 
 
11918 
 
11919 
  def __repr__(self):
11920 
    L = ['%s=%r' % (key, value)
11921 
      for key, value in self.__dict__.iteritems()]
11922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11923 
 
11924 
  def __eq__(self, other):
11925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11926 
 
11927 
  def __ne__(self, other):
11928 
    return not (self == other)
11929 
 
11930 
class deleteBanner_args:
11931 
  """
11932 
  Attributes:
11933 
   - bannerName
11934 
  """
11935 
 
11936 
  thrift_spec = (
11937 
    None, # 0
11938 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11939 
  )
11940 
 
11941 
  def __init__(self, bannerName=None,):
11942 
    self.bannerName = bannerName
11943 
 
11944 
  def read(self, iprot):
11945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11947 
      return
11948 
    iprot.readStructBegin()
11949 
    while True:
11950 
      (fname, ftype, fid) = iprot.readFieldBegin()
11951 
      if ftype == TType.STOP:
11952 
        break
11953 
      if fid == 1:
11954 
        if ftype == TType.STRING:
11955 
          self.bannerName = iprot.readString();
11956 
        else:
11957 
          iprot.skip(ftype)
11958 
      else:
11959 
        iprot.skip(ftype)
11960 
      iprot.readFieldEnd()
11961 
    iprot.readStructEnd()
11962 
 
11963 
  def write(self, oprot):
11964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11966 
      return
11967 
    oprot.writeStructBegin('deleteBanner_args')
11968 
    if self.bannerName is not None:
11969 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11970 
      oprot.writeString(self.bannerName)
11971 
      oprot.writeFieldEnd()
11972 
    oprot.writeFieldStop()
11973 
    oprot.writeStructEnd()
11974 
 
11975 
  def validate(self):
11976 
    return
11977 
 
11978 
 
11979 
  def __repr__(self):
11980 
    L = ['%s=%r' % (key, value)
11981 
      for key, value in self.__dict__.iteritems()]
11982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11983 
 
11984 
  def __eq__(self, other):
11985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11986 
 
11987 
  def __ne__(self, other):
11988 
    return not (self == other)
11989 
 
11990 
class deleteBanner_result:
11991 
  """
11992 
  Attributes:
11993 
   - success
11994 
  """
11995 
 
11996 
  thrift_spec = (
11997 
    (0, TType.BOOL, 'success', None, None, ), # 0
11998 
  )
11999 
 
12000 
  def __init__(self, success=None,):
12001 
    self.success = success
12002 
 
12003 
  def read(self, iprot):
12004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12006 
      return
12007 
    iprot.readStructBegin()
12008 
    while True:
12009 
      (fname, ftype, fid) = iprot.readFieldBegin()
12010 
      if ftype == TType.STOP:
12011 
        break
12012 
      if fid == 0:
12013 
        if ftype == TType.BOOL:
12014 
          self.success = iprot.readBool();
12015 
        else:
12016 
          iprot.skip(ftype)
12017 
      else:
12018 
        iprot.skip(ftype)
12019 
      iprot.readFieldEnd()
12020 
    iprot.readStructEnd()
12021 
 
12022 
  def write(self, oprot):
12023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12025 
      return
12026 
    oprot.writeStructBegin('deleteBanner_result')
12027 
    if self.success is not None:
12028 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12029 
      oprot.writeBool(self.success)
12030 
      oprot.writeFieldEnd()
12031 
    oprot.writeFieldStop()
12032 
    oprot.writeStructEnd()
12033 
 
12034 
  def validate(self):
12035 
    return
12036 
 
12037 
 
12038 
  def __repr__(self):
12039 
    L = ['%s=%r' % (key, value)
12040 
      for key, value in self.__dict__.iteritems()]
12041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12042 
 
12043 
  def __eq__(self, other):
12044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12045 
 
12046 
  def __ne__(self, other):
12047 
    return not (self == other)
12048 
 
12049 
class getBannerDetails_args:
12050 
  """
12051 
  Attributes:
12052 
   - bannerName
12053 
  """
12054 
 
12055 
  thrift_spec = (
12056 
    None, # 0
12057 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12058 
  )
12059 
 
12060 
  def __init__(self, bannerName=None,):
12061 
    self.bannerName = bannerName
12062 
 
12063 
  def read(self, iprot):
12064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12066 
      return
12067 
    iprot.readStructBegin()
12068 
    while True:
12069 
      (fname, ftype, fid) = iprot.readFieldBegin()
12070 
      if ftype == TType.STOP:
12071 
        break
12072 
      if fid == 1:
12073 
        if ftype == TType.STRING:
12074 
          self.bannerName = iprot.readString();
12075 
        else:
12076 
          iprot.skip(ftype)
12077 
      else:
12078 
        iprot.skip(ftype)
12079 
      iprot.readFieldEnd()
12080 
    iprot.readStructEnd()
12081 
 
12082 
  def write(self, oprot):
12083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12085 
      return
12086 
    oprot.writeStructBegin('getBannerDetails_args')
12087 
    if self.bannerName is not None:
12088 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12089 
      oprot.writeString(self.bannerName)
12090 
      oprot.writeFieldEnd()
12091 
    oprot.writeFieldStop()
12092 
    oprot.writeStructEnd()
12093 
 
12094 
  def validate(self):
12095 
    return
12096 
 
12097 
 
12098 
  def __repr__(self):
12099 
    L = ['%s=%r' % (key, value)
12100 
      for key, value in self.__dict__.iteritems()]
12101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12102 
 
12103 
  def __eq__(self, other):
12104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12105 
 
12106 
  def __ne__(self, other):
12107 
    return not (self == other)
12108 
 
12109 
class getBannerDetails_result:
12110 
  """
12111 
  Attributes:
12112 
   - success
12113 
  """
12114 
 
12115 
  thrift_spec = (
12116 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12117 
  )
12118 
 
12119 
  def __init__(self, success=None,):
12120 
    self.success = success
12121 
 
12122 
  def read(self, iprot):
12123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12125 
      return
12126 
    iprot.readStructBegin()
12127 
    while True:
12128 
      (fname, ftype, fid) = iprot.readFieldBegin()
12129 
      if ftype == TType.STOP:
12130 
        break
12131 
      if fid == 0:
12132 
        if ftype == TType.STRUCT:
12133 
          self.success = Banner()
12134 
          self.success.read(iprot)
12135 
        else:
12136 
          iprot.skip(ftype)
12137 
      else:
12138 
        iprot.skip(ftype)
12139 
      iprot.readFieldEnd()
12140 
    iprot.readStructEnd()
12141 
 
12142 
  def write(self, oprot):
12143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12145 
      return
12146 
    oprot.writeStructBegin('getBannerDetails_result')
12147 
    if self.success is not None:
12148 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12149 
      self.success.write(oprot)
12150 
      oprot.writeFieldEnd()
12151 
    oprot.writeFieldStop()
12152 
    oprot.writeStructEnd()
12153 
 
12154 
  def validate(self):
12155 
    return
12156 
 
12157 
 
12158 
  def __repr__(self):
12159 
    L = ['%s=%r' % (key, value)
12160 
      for key, value in self.__dict__.iteritems()]
12161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12162 
 
12163 
  def __eq__(self, other):
12164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12165 
 
12166 
  def __ne__(self, other):
12167 
    return not (self == other)
12168 
 
12169 
class getActiveBanners_args:
12170 
 
12171 
  thrift_spec = (
12172 
  )
12173 
 
12174 
  def read(self, iprot):
12175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12177 
      return
12178 
    iprot.readStructBegin()
12179 
    while True:
12180 
      (fname, ftype, fid) = iprot.readFieldBegin()
12181 
      if ftype == TType.STOP:
12182 
        break
12183 
      else:
12184 
        iprot.skip(ftype)
12185 
      iprot.readFieldEnd()
12186 
    iprot.readStructEnd()
12187 
 
12188 
  def write(self, oprot):
12189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12191 
      return
12192 
    oprot.writeStructBegin('getActiveBanners_args')
12193 
    oprot.writeFieldStop()
12194 
    oprot.writeStructEnd()
12195 
 
12196 
  def validate(self):
12197 
    return
12198 
 
12199 
 
12200 
  def __repr__(self):
12201 
    L = ['%s=%r' % (key, value)
12202 
      for key, value in self.__dict__.iteritems()]
12203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12204 
 
12205 
  def __eq__(self, other):
12206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12207 
 
12208 
  def __ne__(self, other):
12209 
    return not (self == other)
12210 
 
12211 
class getActiveBanners_result:
12212 
  """
12213 
  Attributes:
12214 
   - success
12215 
  """
12216 
 
12217 
  thrift_spec = (
8579 kshitij.so 12218 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12219 
  )
12220 
 
12221 
  def __init__(self, success=None,):
12222 
    self.success = success
12223 
 
12224 
  def read(self, iprot):
12225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12227 
      return
12228 
    iprot.readStructBegin()
12229 
    while True:
12230 
      (fname, ftype, fid) = iprot.readFieldBegin()
12231 
      if ftype == TType.STOP:
12232 
        break
12233 
      if fid == 0:
8579 kshitij.so 12234 
        if ftype == TType.MAP:
12235 
          self.success = {}
8590 kshitij.so 12236 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12237 
          for _i206 in xrange(_size202):
12238 
            _key207 = iprot.readString();
12239 
            _val208 = []
12240 
            (_etype212, _size209) = iprot.readListBegin()
12241 
            for _i213 in xrange(_size209):
12242 
              _elem214 = Banner()
12243 
              _elem214.read(iprot)
12244 
              _val208.append(_elem214)
8579 kshitij.so 12245 
            iprot.readListEnd()
8590 kshitij.so 12246 
            self.success[_key207] = _val208
8579 kshitij.so 12247 
          iprot.readMapEnd()
6850 kshitij.so 12248 
        else:
12249 
          iprot.skip(ftype)
12250 
      else:
12251 
        iprot.skip(ftype)
12252 
      iprot.readFieldEnd()
12253 
    iprot.readStructEnd()
12254 
 
12255 
  def write(self, oprot):
12256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12258 
      return
12259 
    oprot.writeStructBegin('getActiveBanners_result')
12260 
    if self.success is not None:
8579 kshitij.so 12261 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12262 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12263 
      for kiter215,viter216 in self.success.items():
12264 
        oprot.writeString(kiter215)
12265 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12266 
        for iter217 in viter216:
12267 
          iter217.write(oprot)
8579 kshitij.so 12268 
        oprot.writeListEnd()
12269 
      oprot.writeMapEnd()
6850 kshitij.so 12270 
      oprot.writeFieldEnd()
12271 
    oprot.writeFieldStop()
12272 
    oprot.writeStructEnd()
12273 
 
12274 
  def validate(self):
12275 
    return
12276 
 
12277 
 
12278 
  def __repr__(self):
12279 
    L = ['%s=%r' % (key, value)
12280 
      for key, value in self.__dict__.iteritems()]
12281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12282 
 
12283 
  def __eq__(self, other):
12284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12285 
 
12286 
  def __ne__(self, other):
12287 
    return not (self == other)
12288 
 
6849 kshitij.so 12289 
class addBannerMap_args:
12290 
  """
12291 
  Attributes:
8579 kshitij.so 12292 
   - bannerMaps
6849 kshitij.so 12293 
  """
12294 
 
12295 
  thrift_spec = (
12296 
    None, # 0
8579 kshitij.so 12297 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12298 
  )
12299 
 
8579 kshitij.so 12300 
  def __init__(self, bannerMaps=None,):
12301 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12302 
 
12303 
  def read(self, iprot):
12304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12306 
      return
12307 
    iprot.readStructBegin()
12308 
    while True:
12309 
      (fname, ftype, fid) = iprot.readFieldBegin()
12310 
      if ftype == TType.STOP:
12311 
        break
12312 
      if fid == 1:
8579 kshitij.so 12313 
        if ftype == TType.LIST:
12314 
          self.bannerMaps = []
8590 kshitij.so 12315 
          (_etype221, _size218) = iprot.readListBegin()
12316 
          for _i222 in xrange(_size218):
12317 
            _elem223 = BannerMap()
12318 
            _elem223.read(iprot)
12319 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12320 
          iprot.readListEnd()
6849 kshitij.so 12321 
        else:
12322 
          iprot.skip(ftype)
8579 kshitij.so 12323 
      else:
12324 
        iprot.skip(ftype)
12325 
      iprot.readFieldEnd()
12326 
    iprot.readStructEnd()
12327 
 
12328 
  def write(self, oprot):
12329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12331 
      return
12332 
    oprot.writeStructBegin('addBannerMap_args')
12333 
    if self.bannerMaps is not None:
12334 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12335 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12336 
      for iter224 in self.bannerMaps:
12337 
        iter224.write(oprot)
8579 kshitij.so 12338 
      oprot.writeListEnd()
12339 
      oprot.writeFieldEnd()
12340 
    oprot.writeFieldStop()
12341 
    oprot.writeStructEnd()
12342 
 
12343 
  def validate(self):
12344 
    return
12345 
 
12346 
 
12347 
  def __repr__(self):
12348 
    L = ['%s=%r' % (key, value)
12349 
      for key, value in self.__dict__.iteritems()]
12350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12351 
 
12352 
  def __eq__(self, other):
12353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12354 
 
12355 
  def __ne__(self, other):
12356 
    return not (self == other)
12357 
 
12358 
class addBannerMap_result:
12359 
  """
12360 
  Attributes:
12361 
   - success
12362 
  """
12363 
 
12364 
  thrift_spec = (
12365 
    (0, TType.BOOL, 'success', None, None, ), # 0
12366 
  )
12367 
 
12368 
  def __init__(self, success=None,):
12369 
    self.success = success
12370 
 
12371 
  def read(self, iprot):
12372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12374 
      return
12375 
    iprot.readStructBegin()
12376 
    while True:
12377 
      (fname, ftype, fid) = iprot.readFieldBegin()
12378 
      if ftype == TType.STOP:
12379 
        break
12380 
      if fid == 0:
12381 
        if ftype == TType.BOOL:
12382 
          self.success = iprot.readBool();
6849 kshitij.so 12383 
        else:
12384 
          iprot.skip(ftype)
8579 kshitij.so 12385 
      else:
12386 
        iprot.skip(ftype)
12387 
      iprot.readFieldEnd()
12388 
    iprot.readStructEnd()
12389 
 
12390 
  def write(self, oprot):
12391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12393 
      return
12394 
    oprot.writeStructBegin('addBannerMap_result')
12395 
    if self.success is not None:
12396 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12397 
      oprot.writeBool(self.success)
12398 
      oprot.writeFieldEnd()
12399 
    oprot.writeFieldStop()
12400 
    oprot.writeStructEnd()
12401 
 
12402 
  def validate(self):
12403 
    return
12404 
 
12405 
 
12406 
  def __repr__(self):
12407 
    L = ['%s=%r' % (key, value)
12408 
      for key, value in self.__dict__.iteritems()]
12409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12410 
 
12411 
  def __eq__(self, other):
12412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12413 
 
12414 
  def __ne__(self, other):
12415 
    return not (self == other)
12416 
 
12417 
class updateBannerMap_args:
12418 
  """
12419 
  Attributes:
12420 
   - bannerMap
12421 
  """
12422 
 
12423 
  thrift_spec = (
12424 
    None, # 0
12425 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
12426 
  )
12427 
 
12428 
  def __init__(self, bannerMap=None,):
12429 
    self.bannerMap = bannerMap
12430 
 
12431 
  def read(self, iprot):
12432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12434 
      return
12435 
    iprot.readStructBegin()
12436 
    while True:
12437 
      (fname, ftype, fid) = iprot.readFieldBegin()
12438 
      if ftype == TType.STOP:
12439 
        break
12440 
      if fid == 1:
12441 
        if ftype == TType.STRUCT:
12442 
          self.bannerMap = BannerMap()
12443 
          self.bannerMap.read(iprot)
6849 kshitij.so 12444 
        else:
12445 
          iprot.skip(ftype)
12446 
      else:
12447 
        iprot.skip(ftype)
12448 
      iprot.readFieldEnd()
12449 
    iprot.readStructEnd()
12450 
 
12451 
  def write(self, oprot):
12452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12454 
      return
8579 kshitij.so 12455 
    oprot.writeStructBegin('updateBannerMap_args')
12456 
    if self.bannerMap is not None:
12457 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
12458 
      self.bannerMap.write(oprot)
6849 kshitij.so 12459 
      oprot.writeFieldEnd()
12460 
    oprot.writeFieldStop()
12461 
    oprot.writeStructEnd()
12462 
 
12463 
  def validate(self):
12464 
    return
12465 
 
12466 
 
12467 
  def __repr__(self):
12468 
    L = ['%s=%r' % (key, value)
12469 
      for key, value in self.__dict__.iteritems()]
12470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12471 
 
12472 
  def __eq__(self, other):
12473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12474 
 
12475 
  def __ne__(self, other):
12476 
    return not (self == other)
12477 
 
8579 kshitij.so 12478 
class updateBannerMap_result:
6849 kshitij.so 12479 
  """
12480 
  Attributes:
12481 
   - success
12482 
  """
12483 
 
12484 
  thrift_spec = (
12485 
    (0, TType.BOOL, 'success', None, None, ), # 0
12486 
  )
12487 
 
12488 
  def __init__(self, success=None,):
12489 
    self.success = success
12490 
 
12491 
  def read(self, iprot):
12492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12494 
      return
12495 
    iprot.readStructBegin()
12496 
    while True:
12497 
      (fname, ftype, fid) = iprot.readFieldBegin()
12498 
      if ftype == TType.STOP:
12499 
        break
12500 
      if fid == 0:
12501 
        if ftype == TType.BOOL:
12502 
          self.success = iprot.readBool();
12503 
        else:
12504 
          iprot.skip(ftype)
12505 
      else:
12506 
        iprot.skip(ftype)
12507 
      iprot.readFieldEnd()
12508 
    iprot.readStructEnd()
12509 
 
12510 
  def write(self, oprot):
12511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12513 
      return
8579 kshitij.so 12514 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 12515 
    if self.success is not None:
12516 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12517 
      oprot.writeBool(self.success)
12518 
      oprot.writeFieldEnd()
12519 
    oprot.writeFieldStop()
12520 
    oprot.writeStructEnd()
12521 
 
12522 
  def validate(self):
12523 
    return
12524 
 
12525 
 
12526 
  def __repr__(self):
12527 
    L = ['%s=%r' % (key, value)
12528 
      for key, value in self.__dict__.iteritems()]
12529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12530 
 
12531 
  def __eq__(self, other):
12532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12533 
 
12534 
  def __ne__(self, other):
12535 
    return not (self == other)
12536 
 
12537 
class deleteBannerMap_args:
12538 
  """
12539 
  Attributes:
12540 
   - bannerName
12541 
  """
12542 
 
12543 
  thrift_spec = (
12544 
    None, # 0
12545 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12546 
  )
12547 
 
12548 
  def __init__(self, bannerName=None,):
12549 
    self.bannerName = bannerName
12550 
 
12551 
  def read(self, iprot):
12552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12554 
      return
12555 
    iprot.readStructBegin()
12556 
    while True:
12557 
      (fname, ftype, fid) = iprot.readFieldBegin()
12558 
      if ftype == TType.STOP:
12559 
        break
12560 
      if fid == 1:
12561 
        if ftype == TType.STRING:
12562 
          self.bannerName = iprot.readString();
12563 
        else:
12564 
          iprot.skip(ftype)
12565 
      else:
12566 
        iprot.skip(ftype)
12567 
      iprot.readFieldEnd()
12568 
    iprot.readStructEnd()
12569 
 
12570 
  def write(self, oprot):
12571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12573 
      return
12574 
    oprot.writeStructBegin('deleteBannerMap_args')
12575 
    if self.bannerName is not None:
12576 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12577 
      oprot.writeString(self.bannerName)
12578 
      oprot.writeFieldEnd()
12579 
    oprot.writeFieldStop()
12580 
    oprot.writeStructEnd()
12581 
 
12582 
  def validate(self):
12583 
    return
12584 
 
12585 
 
12586 
  def __repr__(self):
12587 
    L = ['%s=%r' % (key, value)
12588 
      for key, value in self.__dict__.iteritems()]
12589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12590 
 
12591 
  def __eq__(self, other):
12592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12593 
 
12594 
  def __ne__(self, other):
12595 
    return not (self == other)
12596 
 
12597 
class deleteBannerMap_result:
12598 
  """
12599 
  Attributes:
12600 
   - success
12601 
  """
12602 
 
12603 
  thrift_spec = (
12604 
    (0, TType.BOOL, 'success', None, None, ), # 0
12605 
  )
12606 
 
12607 
  def __init__(self, success=None,):
12608 
    self.success = success
12609 
 
12610 
  def read(self, iprot):
12611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12613 
      return
12614 
    iprot.readStructBegin()
12615 
    while True:
12616 
      (fname, ftype, fid) = iprot.readFieldBegin()
12617 
      if ftype == TType.STOP:
12618 
        break
12619 
      if fid == 0:
12620 
        if ftype == TType.BOOL:
12621 
          self.success = iprot.readBool();
12622 
        else:
12623 
          iprot.skip(ftype)
12624 
      else:
12625 
        iprot.skip(ftype)
12626 
      iprot.readFieldEnd()
12627 
    iprot.readStructEnd()
12628 
 
12629 
  def write(self, oprot):
12630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12632 
      return
12633 
    oprot.writeStructBegin('deleteBannerMap_result')
12634 
    if self.success is not None:
12635 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12636 
      oprot.writeBool(self.success)
12637 
      oprot.writeFieldEnd()
12638 
    oprot.writeFieldStop()
12639 
    oprot.writeStructEnd()
12640 
 
12641 
  def validate(self):
12642 
    return
12643 
 
12644 
 
12645 
  def __repr__(self):
12646 
    L = ['%s=%r' % (key, value)
12647 
      for key, value in self.__dict__.iteritems()]
12648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12649 
 
12650 
  def __eq__(self, other):
12651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12652 
 
12653 
  def __ne__(self, other):
12654 
    return not (self == other)
12655 
 
12656 
class getBannerMapDetails_args:
12657 
  """
12658 
  Attributes:
12659 
   - bannerName
12660 
  """
12661 
 
12662 
  thrift_spec = (
12663 
    None, # 0
12664 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12665 
  )
12666 
 
12667 
  def __init__(self, bannerName=None,):
12668 
    self.bannerName = bannerName
12669 
 
12670 
  def read(self, iprot):
12671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12673 
      return
12674 
    iprot.readStructBegin()
12675 
    while True:
12676 
      (fname, ftype, fid) = iprot.readFieldBegin()
12677 
      if ftype == TType.STOP:
12678 
        break
12679 
      if fid == 1:
12680 
        if ftype == TType.STRING:
12681 
          self.bannerName = iprot.readString();
12682 
        else:
12683 
          iprot.skip(ftype)
12684 
      else:
12685 
        iprot.skip(ftype)
12686 
      iprot.readFieldEnd()
12687 
    iprot.readStructEnd()
12688 
 
12689 
  def write(self, oprot):
12690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12692 
      return
12693 
    oprot.writeStructBegin('getBannerMapDetails_args')
12694 
    if self.bannerName is not None:
12695 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12696 
      oprot.writeString(self.bannerName)
12697 
      oprot.writeFieldEnd()
12698 
    oprot.writeFieldStop()
12699 
    oprot.writeStructEnd()
12700 
 
12701 
  def validate(self):
12702 
    return
12703 
 
12704 
 
12705 
  def __repr__(self):
12706 
    L = ['%s=%r' % (key, value)
12707 
      for key, value in self.__dict__.iteritems()]
12708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12709 
 
12710 
  def __eq__(self, other):
12711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12712 
 
12713 
  def __ne__(self, other):
12714 
    return not (self == other)
12715 
 
12716 
class getBannerMapDetails_result:
12717 
  """
12718 
  Attributes:
12719 
   - success
12720 
  """
12721 
 
12722 
  thrift_spec = (
12723 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
12724 
  )
12725 
 
12726 
  def __init__(self, success=None,):
12727 
    self.success = success
12728 
 
12729 
  def read(self, iprot):
12730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12732 
      return
12733 
    iprot.readStructBegin()
12734 
    while True:
12735 
      (fname, ftype, fid) = iprot.readFieldBegin()
12736 
      if ftype == TType.STOP:
12737 
        break
12738 
      if fid == 0:
12739 
        if ftype == TType.LIST:
12740 
          self.success = []
8590 kshitij.so 12741 
          (_etype228, _size225) = iprot.readListBegin()
12742 
          for _i229 in xrange(_size225):
12743 
            _elem230 = BannerMap()
12744 
            _elem230.read(iprot)
12745 
            self.success.append(_elem230)
6849 kshitij.so 12746 
          iprot.readListEnd()
12747 
        else:
12748 
          iprot.skip(ftype)
12749 
      else:
12750 
        iprot.skip(ftype)
12751 
      iprot.readFieldEnd()
12752 
    iprot.readStructEnd()
12753 
 
12754 
  def write(self, oprot):
12755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12757 
      return
12758 
    oprot.writeStructBegin('getBannerMapDetails_result')
12759 
    if self.success is not None:
12760 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12761 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12762 
      for iter231 in self.success:
12763 
        iter231.write(oprot)
6849 kshitij.so 12764 
      oprot.writeListEnd()
12765 
      oprot.writeFieldEnd()
12766 
    oprot.writeFieldStop()
12767 
    oprot.writeStructEnd()
12768 
 
12769 
  def validate(self):
12770 
    return
12771 
 
12772 
 
12773 
  def __repr__(self):
12774 
    L = ['%s=%r' % (key, value)
12775 
      for key, value in self.__dict__.iteritems()]
12776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12777 
 
12778 
  def __eq__(self, other):
12779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12780 
 
12781 
  def __ne__(self, other):
12782 
    return not (self == other)
12783 
 
8579 kshitij.so 12784 
class addBannerUri_args:
12785 
  """
12786 
  Attributes:
12787 
   - bannerUriMappings
12788 
  """
12789 
 
12790 
  thrift_spec = (
12791 
    None, # 0
12792 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
12793 
  )
12794 
 
12795 
  def __init__(self, bannerUriMappings=None,):
12796 
    self.bannerUriMappings = bannerUriMappings
12797 
 
12798 
  def read(self, iprot):
12799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12801 
      return
12802 
    iprot.readStructBegin()
12803 
    while True:
12804 
      (fname, ftype, fid) = iprot.readFieldBegin()
12805 
      if ftype == TType.STOP:
12806 
        break
12807 
      if fid == 1:
12808 
        if ftype == TType.LIST:
12809 
          self.bannerUriMappings = []
8590 kshitij.so 12810 
          (_etype235, _size232) = iprot.readListBegin()
12811 
          for _i236 in xrange(_size232):
12812 
            _elem237 = BannerUriMapping()
12813 
            _elem237.read(iprot)
12814 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 12815 
          iprot.readListEnd()
12816 
        else:
12817 
          iprot.skip(ftype)
12818 
      else:
12819 
        iprot.skip(ftype)
12820 
      iprot.readFieldEnd()
12821 
    iprot.readStructEnd()
12822 
 
12823 
  def write(self, oprot):
12824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12826 
      return
12827 
    oprot.writeStructBegin('addBannerUri_args')
12828 
    if self.bannerUriMappings is not None:
12829 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
12830 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 12831 
      for iter238 in self.bannerUriMappings:
12832 
        iter238.write(oprot)
8579 kshitij.so 12833 
      oprot.writeListEnd()
12834 
      oprot.writeFieldEnd()
12835 
    oprot.writeFieldStop()
12836 
    oprot.writeStructEnd()
12837 
 
12838 
  def validate(self):
12839 
    return
12840 
 
12841 
 
12842 
  def __repr__(self):
12843 
    L = ['%s=%r' % (key, value)
12844 
      for key, value in self.__dict__.iteritems()]
12845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12846 
 
12847 
  def __eq__(self, other):
12848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12849 
 
12850 
  def __ne__(self, other):
12851 
    return not (self == other)
12852 
 
12853 
class addBannerUri_result:
12854 
 
12855 
  thrift_spec = (
12856 
  )
12857 
 
12858 
  def read(self, iprot):
12859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12861 
      return
12862 
    iprot.readStructBegin()
12863 
    while True:
12864 
      (fname, ftype, fid) = iprot.readFieldBegin()
12865 
      if ftype == TType.STOP:
12866 
        break
12867 
      else:
12868 
        iprot.skip(ftype)
12869 
      iprot.readFieldEnd()
12870 
    iprot.readStructEnd()
12871 
 
12872 
  def write(self, oprot):
12873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12875 
      return
12876 
    oprot.writeStructBegin('addBannerUri_result')
12877 
    oprot.writeFieldStop()
12878 
    oprot.writeStructEnd()
12879 
 
12880 
  def validate(self):
12881 
    return
12882 
 
12883 
 
12884 
  def __repr__(self):
12885 
    L = ['%s=%r' % (key, value)
12886 
      for key, value in self.__dict__.iteritems()]
12887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12888 
 
12889 
  def __eq__(self, other):
12890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12891 
 
12892 
  def __ne__(self, other):
12893 
    return not (self == other)
12894 
 
12895 
class getUriMapping_args:
12896 
  """
12897 
  Attributes:
12898 
   - bannerName
12899 
  """
12900 
 
12901 
  thrift_spec = (
12902 
    None, # 0
12903 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12904 
  )
12905 
 
12906 
  def __init__(self, bannerName=None,):
12907 
    self.bannerName = bannerName
12908 
 
12909 
  def read(self, iprot):
12910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12912 
      return
12913 
    iprot.readStructBegin()
12914 
    while True:
12915 
      (fname, ftype, fid) = iprot.readFieldBegin()
12916 
      if ftype == TType.STOP:
12917 
        break
12918 
      if fid == 1:
12919 
        if ftype == TType.STRING:
12920 
          self.bannerName = iprot.readString();
12921 
        else:
12922 
          iprot.skip(ftype)
12923 
      else:
12924 
        iprot.skip(ftype)
12925 
      iprot.readFieldEnd()
12926 
    iprot.readStructEnd()
12927 
 
12928 
  def write(self, oprot):
12929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12931 
      return
12932 
    oprot.writeStructBegin('getUriMapping_args')
12933 
    if self.bannerName is not None:
12934 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12935 
      oprot.writeString(self.bannerName)
12936 
      oprot.writeFieldEnd()
12937 
    oprot.writeFieldStop()
12938 
    oprot.writeStructEnd()
12939 
 
12940 
  def validate(self):
12941 
    return
12942 
 
12943 
 
12944 
  def __repr__(self):
12945 
    L = ['%s=%r' % (key, value)
12946 
      for key, value in self.__dict__.iteritems()]
12947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12948 
 
12949 
  def __eq__(self, other):
12950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12951 
 
12952 
  def __ne__(self, other):
12953 
    return not (self == other)
12954 
 
12955 
class getUriMapping_result:
12956 
  """
12957 
  Attributes:
12958 
   - success
12959 
  """
12960 
 
12961 
  thrift_spec = (
12962 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
12963 
  )
12964 
 
12965 
  def __init__(self, success=None,):
12966 
    self.success = success
12967 
 
12968 
  def read(self, iprot):
12969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12971 
      return
12972 
    iprot.readStructBegin()
12973 
    while True:
12974 
      (fname, ftype, fid) = iprot.readFieldBegin()
12975 
      if ftype == TType.STOP:
12976 
        break
12977 
      if fid == 0:
12978 
        if ftype == TType.LIST:
12979 
          self.success = []
8590 kshitij.so 12980 
          (_etype242, _size239) = iprot.readListBegin()
12981 
          for _i243 in xrange(_size239):
12982 
            _elem244 = BannerUriMapping()
12983 
            _elem244.read(iprot)
12984 
            self.success.append(_elem244)
8579 kshitij.so 12985 
          iprot.readListEnd()
12986 
        else:
12987 
          iprot.skip(ftype)
12988 
      else:
12989 
        iprot.skip(ftype)
12990 
      iprot.readFieldEnd()
12991 
    iprot.readStructEnd()
12992 
 
12993 
  def write(self, oprot):
12994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12996 
      return
12997 
    oprot.writeStructBegin('getUriMapping_result')
12998 
    if self.success is not None:
12999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13001 
      for iter245 in self.success:
13002 
        iter245.write(oprot)
8579 kshitij.so 13003 
      oprot.writeListEnd()
13004 
      oprot.writeFieldEnd()
13005 
    oprot.writeFieldStop()
13006 
    oprot.writeStructEnd()
13007 
 
13008 
  def validate(self):
13009 
    return
13010 
 
13011 
 
13012 
  def __repr__(self):
13013 
    L = ['%s=%r' % (key, value)
13014 
      for key, value in self.__dict__.iteritems()]
13015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13016 
 
13017 
  def __eq__(self, other):
13018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13019 
 
13020 
  def __ne__(self, other):
13021 
    return not (self == other)
13022 
 
13023 
class addCampaign_args:
13024 
  """
13025 
  Attributes:
13026 
   - campaign
13027 
  """
13028 
 
13029 
  thrift_spec = (
13030 
    None, # 0
13031 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13032 
  )
13033 
 
13034 
  def __init__(self, campaign=None,):
13035 
    self.campaign = campaign
13036 
 
13037 
  def read(self, iprot):
13038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13040 
      return
13041 
    iprot.readStructBegin()
13042 
    while True:
13043 
      (fname, ftype, fid) = iprot.readFieldBegin()
13044 
      if ftype == TType.STOP:
13045 
        break
13046 
      if fid == 1:
13047 
        if ftype == TType.STRUCT:
13048 
          self.campaign = Campaign()
13049 
          self.campaign.read(iprot)
13050 
        else:
13051 
          iprot.skip(ftype)
13052 
      else:
13053 
        iprot.skip(ftype)
13054 
      iprot.readFieldEnd()
13055 
    iprot.readStructEnd()
13056 
 
13057 
  def write(self, oprot):
13058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13060 
      return
13061 
    oprot.writeStructBegin('addCampaign_args')
13062 
    if self.campaign is not None:
13063 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13064 
      self.campaign.write(oprot)
13065 
      oprot.writeFieldEnd()
13066 
    oprot.writeFieldStop()
13067 
    oprot.writeStructEnd()
13068 
 
13069 
  def validate(self):
13070 
    return
13071 
 
13072 
 
13073 
  def __repr__(self):
13074 
    L = ['%s=%r' % (key, value)
13075 
      for key, value in self.__dict__.iteritems()]
13076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13077 
 
13078 
  def __eq__(self, other):
13079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13080 
 
13081 
  def __ne__(self, other):
13082 
    return not (self == other)
13083 
 
13084 
class addCampaign_result:
13085 
 
13086 
  thrift_spec = (
13087 
  )
13088 
 
13089 
  def read(self, iprot):
13090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13092 
      return
13093 
    iprot.readStructBegin()
13094 
    while True:
13095 
      (fname, ftype, fid) = iprot.readFieldBegin()
13096 
      if ftype == TType.STOP:
13097 
        break
13098 
      else:
13099 
        iprot.skip(ftype)
13100 
      iprot.readFieldEnd()
13101 
    iprot.readStructEnd()
13102 
 
13103 
  def write(self, oprot):
13104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13106 
      return
13107 
    oprot.writeStructBegin('addCampaign_result')
13108 
    oprot.writeFieldStop()
13109 
    oprot.writeStructEnd()
13110 
 
13111 
  def validate(self):
13112 
    return
13113 
 
13114 
 
13115 
  def __repr__(self):
13116 
    L = ['%s=%r' % (key, value)
13117 
      for key, value in self.__dict__.iteritems()]
13118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13119 
 
13120 
  def __eq__(self, other):
13121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13122 
 
13123 
  def __ne__(self, other):
13124 
    return not (self == other)
13125 
 
13126 
class getCampaigns_args:
13127 
  """
13128 
  Attributes:
13129 
   - campaignName
13130 
  """
13131 
 
13132 
  thrift_spec = (
13133 
    None, # 0
13134 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13135 
  )
13136 
 
13137 
  def __init__(self, campaignName=None,):
13138 
    self.campaignName = campaignName
13139 
 
13140 
  def read(self, iprot):
13141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13143 
      return
13144 
    iprot.readStructBegin()
13145 
    while True:
13146 
      (fname, ftype, fid) = iprot.readFieldBegin()
13147 
      if ftype == TType.STOP:
13148 
        break
13149 
      if fid == 1:
13150 
        if ftype == TType.STRING:
13151 
          self.campaignName = iprot.readString();
13152 
        else:
13153 
          iprot.skip(ftype)
13154 
      else:
13155 
        iprot.skip(ftype)
13156 
      iprot.readFieldEnd()
13157 
    iprot.readStructEnd()
13158 
 
13159 
  def write(self, oprot):
13160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13162 
      return
13163 
    oprot.writeStructBegin('getCampaigns_args')
13164 
    if self.campaignName is not None:
13165 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13166 
      oprot.writeString(self.campaignName)
13167 
      oprot.writeFieldEnd()
13168 
    oprot.writeFieldStop()
13169 
    oprot.writeStructEnd()
13170 
 
13171 
  def validate(self):
13172 
    return
13173 
 
13174 
 
13175 
  def __repr__(self):
13176 
    L = ['%s=%r' % (key, value)
13177 
      for key, value in self.__dict__.iteritems()]
13178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13179 
 
13180 
  def __eq__(self, other):
13181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13182 
 
13183 
  def __ne__(self, other):
13184 
    return not (self == other)
13185 
 
13186 
class getCampaigns_result:
13187 
  """
13188 
  Attributes:
13189 
   - success
13190 
  """
13191 
 
13192 
  thrift_spec = (
13193 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13194 
  )
13195 
 
13196 
  def __init__(self, success=None,):
13197 
    self.success = success
13198 
 
13199 
  def read(self, iprot):
13200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13202 
      return
13203 
    iprot.readStructBegin()
13204 
    while True:
13205 
      (fname, ftype, fid) = iprot.readFieldBegin()
13206 
      if ftype == TType.STOP:
13207 
        break
13208 
      if fid == 0:
13209 
        if ftype == TType.LIST:
13210 
          self.success = []
8590 kshitij.so 13211 
          (_etype249, _size246) = iprot.readListBegin()
13212 
          for _i250 in xrange(_size246):
13213 
            _elem251 = Campaign()
13214 
            _elem251.read(iprot)
13215 
            self.success.append(_elem251)
8579 kshitij.so 13216 
          iprot.readListEnd()
13217 
        else:
13218 
          iprot.skip(ftype)
13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
13228 
    oprot.writeStructBegin('getCampaigns_result')
13229 
    if self.success is not None:
13230 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13231 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13232 
      for iter252 in self.success:
13233 
        iter252.write(oprot)
8579 kshitij.so 13234 
      oprot.writeListEnd()
13235 
      oprot.writeFieldEnd()
13236 
    oprot.writeFieldStop()
13237 
    oprot.writeStructEnd()
13238 
 
13239 
  def validate(self):
13240 
    return
13241 
 
13242 
 
13243 
  def __repr__(self):
13244 
    L = ['%s=%r' % (key, value)
13245 
      for key, value in self.__dict__.iteritems()]
13246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13247 
 
13248 
  def __eq__(self, other):
13249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13250 
 
13251 
  def __ne__(self, other):
13252 
    return not (self == other)
13253 
 
13254 
class deleteCampaign_args:
13255 
  """
13256 
  Attributes:
13257 
   - campaignId
13258 
  """
13259 
 
13260 
  thrift_spec = (
13261 
    None, # 0
13262 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13263 
  )
13264 
 
13265 
  def __init__(self, campaignId=None,):
13266 
    self.campaignId = campaignId
13267 
 
13268 
  def read(self, iprot):
13269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13271 
      return
13272 
    iprot.readStructBegin()
13273 
    while True:
13274 
      (fname, ftype, fid) = iprot.readFieldBegin()
13275 
      if ftype == TType.STOP:
13276 
        break
13277 
      if fid == 1:
13278 
        if ftype == TType.I64:
13279 
          self.campaignId = iprot.readI64();
13280 
        else:
13281 
          iprot.skip(ftype)
13282 
      else:
13283 
        iprot.skip(ftype)
13284 
      iprot.readFieldEnd()
13285 
    iprot.readStructEnd()
13286 
 
13287 
  def write(self, oprot):
13288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13290 
      return
13291 
    oprot.writeStructBegin('deleteCampaign_args')
13292 
    if self.campaignId is not None:
13293 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13294 
      oprot.writeI64(self.campaignId)
13295 
      oprot.writeFieldEnd()
13296 
    oprot.writeFieldStop()
13297 
    oprot.writeStructEnd()
13298 
 
13299 
  def validate(self):
13300 
    return
13301 
 
13302 
 
13303 
  def __repr__(self):
13304 
    L = ['%s=%r' % (key, value)
13305 
      for key, value in self.__dict__.iteritems()]
13306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13307 
 
13308 
  def __eq__(self, other):
13309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13310 
 
13311 
  def __ne__(self, other):
13312 
    return not (self == other)
13313 
 
13314 
class deleteCampaign_result:
13315 
 
13316 
  thrift_spec = (
13317 
  )
13318 
 
13319 
  def read(self, iprot):
13320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13322 
      return
13323 
    iprot.readStructBegin()
13324 
    while True:
13325 
      (fname, ftype, fid) = iprot.readFieldBegin()
13326 
      if ftype == TType.STOP:
13327 
        break
13328 
      else:
13329 
        iprot.skip(ftype)
13330 
      iprot.readFieldEnd()
13331 
    iprot.readStructEnd()
13332 
 
13333 
  def write(self, oprot):
13334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13336 
      return
13337 
    oprot.writeStructBegin('deleteCampaign_result')
13338 
    oprot.writeFieldStop()
13339 
    oprot.writeStructEnd()
13340 
 
13341 
  def validate(self):
13342 
    return
13343 
 
13344 
 
13345 
  def __repr__(self):
13346 
    L = ['%s=%r' % (key, value)
13347 
      for key, value in self.__dict__.iteritems()]
13348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13349 
 
13350 
  def __eq__(self, other):
13351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13352 
 
13353 
  def __ne__(self, other):
13354 
    return not (self == other)
13355 
 
13356 
class getAllCampaigns_args:
13357 
 
13358 
  thrift_spec = (
13359 
  )
13360 
 
13361 
  def read(self, iprot):
13362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13364 
      return
13365 
    iprot.readStructBegin()
13366 
    while True:
13367 
      (fname, ftype, fid) = iprot.readFieldBegin()
13368 
      if ftype == TType.STOP:
13369 
        break
13370 
      else:
13371 
        iprot.skip(ftype)
13372 
      iprot.readFieldEnd()
13373 
    iprot.readStructEnd()
13374 
 
13375 
  def write(self, oprot):
13376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13378 
      return
13379 
    oprot.writeStructBegin('getAllCampaigns_args')
13380 
    oprot.writeFieldStop()
13381 
    oprot.writeStructEnd()
13382 
 
13383 
  def validate(self):
13384 
    return
13385 
 
13386 
 
13387 
  def __repr__(self):
13388 
    L = ['%s=%r' % (key, value)
13389 
      for key, value in self.__dict__.iteritems()]
13390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13391 
 
13392 
  def __eq__(self, other):
13393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13394 
 
13395 
  def __ne__(self, other):
13396 
    return not (self == other)
13397 
 
13398 
class getAllCampaigns_result:
13399 
  """
13400 
  Attributes:
13401 
   - success
13402 
  """
13403 
 
13404 
  thrift_spec = (
13405 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13406 
  )
13407 
 
13408 
  def __init__(self, success=None,):
13409 
    self.success = success
13410 
 
13411 
  def read(self, iprot):
13412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13414 
      return
13415 
    iprot.readStructBegin()
13416 
    while True:
13417 
      (fname, ftype, fid) = iprot.readFieldBegin()
13418 
      if ftype == TType.STOP:
13419 
        break
13420 
      if fid == 0:
13421 
        if ftype == TType.LIST:
13422 
          self.success = []
8590 kshitij.so 13423 
          (_etype256, _size253) = iprot.readListBegin()
13424 
          for _i257 in xrange(_size253):
13425 
            _elem258 = iprot.readString();
13426 
            self.success.append(_elem258)
8579 kshitij.so 13427 
          iprot.readListEnd()
13428 
        else:
13429 
          iprot.skip(ftype)
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('getAllCampaigns_result')
13440 
    if self.success is not None:
13441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13442 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13443 
      for iter259 in self.success:
13444 
        oprot.writeString(iter259)
8579 kshitij.so 13445 
      oprot.writeListEnd()
13446 
      oprot.writeFieldEnd()
13447 
    oprot.writeFieldStop()
13448 
    oprot.writeStructEnd()
13449 
 
13450 
  def validate(self):
13451 
    return
13452 
 
13453 
 
13454 
  def __repr__(self):
13455 
    L = ['%s=%r' % (key, value)
13456 
      for key, value in self.__dict__.iteritems()]
13457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13458 
 
13459 
  def __eq__(self, other):
13460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13461 
 
13462 
  def __ne__(self, other):
13463 
    return not (self == other)
13464 
 
5944 mandeep.dh 13465 
class deleteSimilarItem_args:
13466 
  """
13467 
  Attributes:
13468 
   - itemId
13469 
   - catalogItemId
13470 
  """
13471 
 
13472 
  thrift_spec = (
13473 
    None, # 0
13474 
    (1, TType.I64, 'itemId', None, None, ), # 1
13475 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
13476 
  )
13477 
 
13478 
  def __init__(self, itemId=None, catalogItemId=None,):
13479 
    self.itemId = itemId
13480 
    self.catalogItemId = catalogItemId
13481 
 
13482 
  def read(self, iprot):
13483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13485 
      return
13486 
    iprot.readStructBegin()
13487 
    while True:
13488 
      (fname, ftype, fid) = iprot.readFieldBegin()
13489 
      if ftype == TType.STOP:
13490 
        break
13491 
      if fid == 1:
13492 
        if ftype == TType.I64:
13493 
          self.itemId = iprot.readI64();
13494 
        else:
13495 
          iprot.skip(ftype)
13496 
      elif fid == 2:
13497 
        if ftype == TType.I64:
13498 
          self.catalogItemId = iprot.readI64();
13499 
        else:
13500 
          iprot.skip(ftype)
13501 
      else:
13502 
        iprot.skip(ftype)
13503 
      iprot.readFieldEnd()
13504 
    iprot.readStructEnd()
13505 
 
13506 
  def write(self, oprot):
13507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13509 
      return
13510 
    oprot.writeStructBegin('deleteSimilarItem_args')
13511 
    if self.itemId is not None:
13512 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13513 
      oprot.writeI64(self.itemId)
13514 
      oprot.writeFieldEnd()
13515 
    if self.catalogItemId is not None:
13516 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13517 
      oprot.writeI64(self.catalogItemId)
13518 
      oprot.writeFieldEnd()
13519 
    oprot.writeFieldStop()
13520 
    oprot.writeStructEnd()
13521 
 
13522 
  def validate(self):
13523 
    return
13524 
 
13525 
 
13526 
  def __repr__(self):
13527 
    L = ['%s=%r' % (key, value)
13528 
      for key, value in self.__dict__.iteritems()]
13529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13530 
 
13531 
  def __eq__(self, other):
13532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13533 
 
13534 
  def __ne__(self, other):
13535 
    return not (self == other)
13536 
 
13537 
class deleteSimilarItem_result:
13538 
  """
13539 
  Attributes:
13540 
   - success
13541 
   - cex
13542 
  """
13543 
 
13544 
  thrift_spec = (
13545 
    (0, TType.BOOL, 'success', None, None, ), # 0
13546 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13547 
  )
13548 
 
13549 
  def __init__(self, success=None, cex=None,):
13550 
    self.success = success
13551 
    self.cex = cex
13552 
 
13553 
  def read(self, iprot):
13554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13556 
      return
13557 
    iprot.readStructBegin()
13558 
    while True:
13559 
      (fname, ftype, fid) = iprot.readFieldBegin()
13560 
      if ftype == TType.STOP:
13561 
        break
13562 
      if fid == 0:
13563 
        if ftype == TType.BOOL:
13564 
          self.success = iprot.readBool();
13565 
        else:
13566 
          iprot.skip(ftype)
13567 
      elif fid == 1:
13568 
        if ftype == TType.STRUCT:
13569 
          self.cex = CatalogServiceException()
13570 
          self.cex.read(iprot)
13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      else:
13574 
        iprot.skip(ftype)
13575 
      iprot.readFieldEnd()
13576 
    iprot.readStructEnd()
13577 
 
13578 
  def write(self, oprot):
13579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13581 
      return
13582 
    oprot.writeStructBegin('deleteSimilarItem_result')
13583 
    if self.success is not None:
13584 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13585 
      oprot.writeBool(self.success)
13586 
      oprot.writeFieldEnd()
13587 
    if self.cex is not None:
13588 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13589 
      self.cex.write(oprot)
13590 
      oprot.writeFieldEnd()
13591 
    oprot.writeFieldStop()
13592 
    oprot.writeStructEnd()
13593 
 
13594 
  def validate(self):
13595 
    return
13596 
 
13597 
 
13598 
  def __repr__(self):
13599 
    L = ['%s=%r' % (key, value)
13600 
      for key, value in self.__dict__.iteritems()]
13601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13602 
 
13603 
  def __eq__(self, other):
13604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13605 
 
13606 
  def __ne__(self, other):
13607 
    return not (self == other)
13608 
 
13609 
class checkSimilarItem_args:
13610 
  """
13611 
  Attributes:
13612 
   - brand
13613 
   - modelNumber
13614 
   - modelName
13615 
   - color
13616 
  """
13617 
 
13618 
  thrift_spec = (
13619 
    None, # 0
13620 
    (1, TType.STRING, 'brand', None, None, ), # 1
13621 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
13622 
    (3, TType.STRING, 'modelName', None, None, ), # 3
13623 
    (4, TType.STRING, 'color', None, None, ), # 4
13624 
  )
13625 
 
13626 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
13627 
    self.brand = brand
13628 
    self.modelNumber = modelNumber
13629 
    self.modelName = modelName
13630 
    self.color = color
13631 
 
13632 
  def read(self, iprot):
13633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13635 
      return
13636 
    iprot.readStructBegin()
13637 
    while True:
13638 
      (fname, ftype, fid) = iprot.readFieldBegin()
13639 
      if ftype == TType.STOP:
13640 
        break
13641 
      if fid == 1:
13642 
        if ftype == TType.STRING:
13643 
          self.brand = iprot.readString();
13644 
        else:
13645 
          iprot.skip(ftype)
13646 
      elif fid == 2:
13647 
        if ftype == TType.STRING:
13648 
          self.modelNumber = iprot.readString();
13649 
        else:
13650 
          iprot.skip(ftype)
13651 
      elif fid == 3:
13652 
        if ftype == TType.STRING:
13653 
          self.modelName = iprot.readString();
13654 
        else:
13655 
          iprot.skip(ftype)
13656 
      elif fid == 4:
13657 
        if ftype == TType.STRING:
13658 
          self.color = iprot.readString();
13659 
        else:
13660 
          iprot.skip(ftype)
13661 
      else:
13662 
        iprot.skip(ftype)
13663 
      iprot.readFieldEnd()
13664 
    iprot.readStructEnd()
13665 
 
13666 
  def write(self, oprot):
13667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13669 
      return
13670 
    oprot.writeStructBegin('checkSimilarItem_args')
13671 
    if self.brand is not None:
13672 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
13673 
      oprot.writeString(self.brand)
13674 
      oprot.writeFieldEnd()
13675 
    if self.modelNumber is not None:
13676 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
13677 
      oprot.writeString(self.modelNumber)
13678 
      oprot.writeFieldEnd()
13679 
    if self.modelName is not None:
13680 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
13681 
      oprot.writeString(self.modelName)
13682 
      oprot.writeFieldEnd()
13683 
    if self.color is not None:
13684 
      oprot.writeFieldBegin('color', TType.STRING, 4)
13685 
      oprot.writeString(self.color)
13686 
      oprot.writeFieldEnd()
13687 
    oprot.writeFieldStop()
13688 
    oprot.writeStructEnd()
13689 
 
13690 
  def validate(self):
13691 
    return
13692 
 
13693 
 
13694 
  def __repr__(self):
13695 
    L = ['%s=%r' % (key, value)
13696 
      for key, value in self.__dict__.iteritems()]
13697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13698 
 
13699 
  def __eq__(self, other):
13700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13701 
 
13702 
  def __ne__(self, other):
13703 
    return not (self == other)
13704 
 
13705 
class checkSimilarItem_result:
13706 
  """
13707 
  Attributes:
13708 
   - success
13709 
  """
13710 
 
13711 
  thrift_spec = (
13712 
    (0, TType.I64, 'success', None, None, ), # 0
13713 
  )
13714 
 
13715 
  def __init__(self, success=None,):
13716 
    self.success = success
13717 
 
13718 
  def read(self, iprot):
13719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13721 
      return
13722 
    iprot.readStructBegin()
13723 
    while True:
13724 
      (fname, ftype, fid) = iprot.readFieldBegin()
13725 
      if ftype == TType.STOP:
13726 
        break
13727 
      if fid == 0:
13728 
        if ftype == TType.I64:
13729 
          self.success = iprot.readI64();
13730 
        else:
13731 
          iprot.skip(ftype)
13732 
      else:
13733 
        iprot.skip(ftype)
13734 
      iprot.readFieldEnd()
13735 
    iprot.readStructEnd()
13736 
 
13737 
  def write(self, oprot):
13738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13740 
      return
13741 
    oprot.writeStructBegin('checkSimilarItem_result')
13742 
    if self.success is not None:
13743 
      oprot.writeFieldBegin('success', TType.I64, 0)
13744 
      oprot.writeI64(self.success)
13745 
      oprot.writeFieldEnd()
13746 
    oprot.writeFieldStop()
13747 
    oprot.writeStructEnd()
13748 
 
13749 
  def validate(self):
13750 
    return
13751 
 
13752 
 
13753 
  def __repr__(self):
13754 
    L = ['%s=%r' % (key, value)
13755 
      for key, value in self.__dict__.iteritems()]
13756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13757 
 
13758 
  def __eq__(self, other):
13759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13760 
 
13761 
  def __ne__(self, other):
13762 
    return not (self == other)
13763 
 
13764 
class validateRiskyStatus_args:
13765 
  """
13766 
  Attributes:
13767 
   - itemId
13768 
  """
13769 
 
13770 
  thrift_spec = (
13771 
    None, # 0
13772 
    (1, TType.I64, 'itemId', None, None, ), # 1
13773 
  )
13774 
 
13775 
  def __init__(self, itemId=None,):
13776 
    self.itemId = itemId
13777 
 
13778 
  def read(self, iprot):
13779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13781 
      return
13782 
    iprot.readStructBegin()
13783 
    while True:
13784 
      (fname, ftype, fid) = iprot.readFieldBegin()
13785 
      if ftype == TType.STOP:
13786 
        break
13787 
      if fid == 1:
13788 
        if ftype == TType.I64:
13789 
          self.itemId = iprot.readI64();
13790 
        else:
13791 
          iprot.skip(ftype)
13792 
      else:
13793 
        iprot.skip(ftype)
13794 
      iprot.readFieldEnd()
13795 
    iprot.readStructEnd()
13796 
 
13797 
  def write(self, oprot):
13798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13800 
      return
13801 
    oprot.writeStructBegin('validateRiskyStatus_args')
13802 
    if self.itemId is not None:
13803 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13804 
      oprot.writeI64(self.itemId)
13805 
      oprot.writeFieldEnd()
13806 
    oprot.writeFieldStop()
13807 
    oprot.writeStructEnd()
13808 
 
13809 
  def validate(self):
13810 
    return
13811 
 
13812 
 
13813 
  def __repr__(self):
13814 
    L = ['%s=%r' % (key, value)
13815 
      for key, value in self.__dict__.iteritems()]
13816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13817 
 
13818 
  def __eq__(self, other):
13819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13820 
 
13821 
  def __ne__(self, other):
13822 
    return not (self == other)
13823 
 
13824 
class validateRiskyStatus_result:
13825 
 
13826 
  thrift_spec = (
13827 
  )
13828 
 
13829 
  def read(self, iprot):
13830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13832 
      return
13833 
    iprot.readStructBegin()
13834 
    while True:
13835 
      (fname, ftype, fid) = iprot.readFieldBegin()
13836 
      if ftype == TType.STOP:
13837 
        break
13838 
      else:
13839 
        iprot.skip(ftype)
13840 
      iprot.readFieldEnd()
13841 
    iprot.readStructEnd()
13842 
 
13843 
  def write(self, oprot):
13844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13846 
      return
13847 
    oprot.writeStructBegin('validateRiskyStatus_result')
13848 
    oprot.writeFieldStop()
13849 
    oprot.writeStructEnd()
13850 
 
13851 
  def validate(self):
13852 
    return
13853 
 
13854 
 
13855 
  def __repr__(self):
13856 
    L = ['%s=%r' % (key, value)
13857 
      for key, value in self.__dict__.iteritems()]
13858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13859 
 
13860 
  def __eq__(self, other):
13861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13862 
 
13863 
  def __ne__(self, other):
13864 
    return not (self == other)
13865 
 
13866 
class changeItemRiskyFlag_args:
13867 
  """
13868 
  Attributes:
13869 
   - itemId
13870 
   - risky
13871 
  """
13872 
 
13873 
  thrift_spec = (
13874 
    None, # 0
13875 
    (1, TType.I64, 'itemId', None, None, ), # 1
13876 
    (2, TType.BOOL, 'risky', None, None, ), # 2
13877 
  )
13878 
 
13879 
  def __init__(self, itemId=None, risky=None,):
13880 
    self.itemId = itemId
13881 
    self.risky = risky
13882 
 
13883 
  def read(self, iprot):
13884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13886 
      return
13887 
    iprot.readStructBegin()
13888 
    while True:
13889 
      (fname, ftype, fid) = iprot.readFieldBegin()
13890 
      if ftype == TType.STOP:
13891 
        break
13892 
      if fid == 1:
13893 
        if ftype == TType.I64:
13894 
          self.itemId = iprot.readI64();
13895 
        else:
13896 
          iprot.skip(ftype)
13897 
      elif fid == 2:
13898 
        if ftype == TType.BOOL:
13899 
          self.risky = iprot.readBool();
13900 
        else:
13901 
          iprot.skip(ftype)
13902 
      else:
13903 
        iprot.skip(ftype)
13904 
      iprot.readFieldEnd()
13905 
    iprot.readStructEnd()
13906 
 
13907 
  def write(self, oprot):
13908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13910 
      return
13911 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
13912 
    if self.itemId is not None:
13913 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13914 
      oprot.writeI64(self.itemId)
13915 
      oprot.writeFieldEnd()
13916 
    if self.risky is not None:
13917 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
13918 
      oprot.writeBool(self.risky)
13919 
      oprot.writeFieldEnd()
13920 
    oprot.writeFieldStop()
13921 
    oprot.writeStructEnd()
13922 
 
13923 
  def validate(self):
13924 
    return
13925 
 
13926 
 
13927 
  def __repr__(self):
13928 
    L = ['%s=%r' % (key, value)
13929 
      for key, value in self.__dict__.iteritems()]
13930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13931 
 
13932 
  def __eq__(self, other):
13933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13934 
 
13935 
  def __ne__(self, other):
13936 
    return not (self == other)
13937 
 
13938 
class changeItemRiskyFlag_result:
13939 
 
13940 
  thrift_spec = (
13941 
  )
13942 
 
13943 
  def read(self, iprot):
13944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13946 
      return
13947 
    iprot.readStructBegin()
13948 
    while True:
13949 
      (fname, ftype, fid) = iprot.readFieldBegin()
13950 
      if ftype == TType.STOP:
13951 
        break
13952 
      else:
13953 
        iprot.skip(ftype)
13954 
      iprot.readFieldEnd()
13955 
    iprot.readStructEnd()
13956 
 
13957 
  def write(self, oprot):
13958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13960 
      return
13961 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
13962 
    oprot.writeFieldStop()
13963 
    oprot.writeStructEnd()
13964 
 
13965 
  def validate(self):
13966 
    return
13967 
 
13968 
 
13969 
  def __repr__(self):
13970 
    L = ['%s=%r' % (key, value)
13971 
      for key, value in self.__dict__.iteritems()]
13972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13973 
 
13974 
  def __eq__(self, other):
13975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13976 
 
13977 
  def __ne__(self, other):
13978 
    return not (self == other)
13979 
 
13980 
class getItemsByRiskyFlag_args:
13981 
 
13982 
  thrift_spec = (
13983 
  )
13984 
 
13985 
  def read(self, iprot):
13986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13988 
      return
13989 
    iprot.readStructBegin()
13990 
    while True:
13991 
      (fname, ftype, fid) = iprot.readFieldBegin()
13992 
      if ftype == TType.STOP:
13993 
        break
13994 
      else:
13995 
        iprot.skip(ftype)
13996 
      iprot.readFieldEnd()
13997 
    iprot.readStructEnd()
13998 
 
13999 
  def write(self, oprot):
14000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14002 
      return
14003 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14004 
    oprot.writeFieldStop()
14005 
    oprot.writeStructEnd()
14006 
 
14007 
  def validate(self):
14008 
    return
14009 
 
14010 
 
14011 
  def __repr__(self):
14012 
    L = ['%s=%r' % (key, value)
14013 
      for key, value in self.__dict__.iteritems()]
14014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14015 
 
14016 
  def __eq__(self, other):
14017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14018 
 
14019 
  def __ne__(self, other):
14020 
    return not (self == other)
14021 
 
14022 
class getItemsByRiskyFlag_result:
14023 
  """
14024 
  Attributes:
14025 
   - success
14026 
  """
14027 
 
14028 
  thrift_spec = (
14029 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14030 
  )
14031 
 
14032 
  def __init__(self, success=None,):
14033 
    self.success = success
14034 
 
14035 
  def read(self, iprot):
14036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14038 
      return
14039 
    iprot.readStructBegin()
14040 
    while True:
14041 
      (fname, ftype, fid) = iprot.readFieldBegin()
14042 
      if ftype == TType.STOP:
14043 
        break
14044 
      if fid == 0:
14045 
        if ftype == TType.LIST:
14046 
          self.success = []
8590 kshitij.so 14047 
          (_etype263, _size260) = iprot.readListBegin()
14048 
          for _i264 in xrange(_size260):
14049 
            _elem265 = Item()
14050 
            _elem265.read(iprot)
14051 
            self.success.append(_elem265)
5944 mandeep.dh 14052 
          iprot.readListEnd()
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      else:
14056 
        iprot.skip(ftype)
14057 
      iprot.readFieldEnd()
14058 
    iprot.readStructEnd()
14059 
 
14060 
  def write(self, oprot):
14061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14063 
      return
14064 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14065 
    if self.success is not None:
14066 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14067 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14068 
      for iter266 in self.success:
14069 
        iter266.write(oprot)
5944 mandeep.dh 14070 
      oprot.writeListEnd()
14071 
      oprot.writeFieldEnd()
14072 
    oprot.writeFieldStop()
14073 
    oprot.writeStructEnd()
14074 
 
14075 
  def validate(self):
14076 
    return
14077 
 
14078 
 
14079 
  def __repr__(self):
14080 
    L = ['%s=%r' % (key, value)
14081 
      for key, value in self.__dict__.iteritems()]
14082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14083 
 
14084 
  def __eq__(self, other):
14085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14086 
 
14087 
  def __ne__(self, other):
14088 
    return not (self == other)
14089 
 
14090 
class getItemsForMasterSheet_args:
14091 
  """
14092 
  Attributes:
14093 
   - category
14094 
   - brand
14095 
  """
14096 
 
14097 
  thrift_spec = (
14098 
    None, # 0
14099 
    (1, TType.STRING, 'category', None, None, ), # 1
14100 
    (2, TType.STRING, 'brand', None, None, ), # 2
14101 
  )
14102 
 
14103 
  def __init__(self, category=None, brand=None,):
14104 
    self.category = category
14105 
    self.brand = brand
14106 
 
14107 
  def read(self, iprot):
14108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14110 
      return
14111 
    iprot.readStructBegin()
14112 
    while True:
14113 
      (fname, ftype, fid) = iprot.readFieldBegin()
14114 
      if ftype == TType.STOP:
14115 
        break
14116 
      if fid == 1:
14117 
        if ftype == TType.STRING:
14118 
          self.category = iprot.readString();
14119 
        else:
14120 
          iprot.skip(ftype)
14121 
      elif fid == 2:
14122 
        if ftype == TType.STRING:
14123 
          self.brand = iprot.readString();
14124 
        else:
14125 
          iprot.skip(ftype)
14126 
      else:
14127 
        iprot.skip(ftype)
14128 
      iprot.readFieldEnd()
14129 
    iprot.readStructEnd()
14130 
 
14131 
  def write(self, oprot):
14132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14134 
      return
14135 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14136 
    if self.category is not None:
14137 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14138 
      oprot.writeString(self.category)
14139 
      oprot.writeFieldEnd()
14140 
    if self.brand is not None:
14141 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14142 
      oprot.writeString(self.brand)
14143 
      oprot.writeFieldEnd()
14144 
    oprot.writeFieldStop()
14145 
    oprot.writeStructEnd()
14146 
 
14147 
  def validate(self):
14148 
    return
14149 
 
14150 
 
14151 
  def __repr__(self):
14152 
    L = ['%s=%r' % (key, value)
14153 
      for key, value in self.__dict__.iteritems()]
14154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14155 
 
14156 
  def __eq__(self, other):
14157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14158 
 
14159 
  def __ne__(self, other):
14160 
    return not (self == other)
14161 
 
14162 
class getItemsForMasterSheet_result:
14163 
  """
14164 
  Attributes:
14165 
   - success
14166 
  """
14167 
 
14168 
  thrift_spec = (
14169 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14170 
  )
14171 
 
14172 
  def __init__(self, success=None,):
14173 
    self.success = success
14174 
 
14175 
  def read(self, iprot):
14176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14178 
      return
14179 
    iprot.readStructBegin()
14180 
    while True:
14181 
      (fname, ftype, fid) = iprot.readFieldBegin()
14182 
      if ftype == TType.STOP:
14183 
        break
14184 
      if fid == 0:
14185 
        if ftype == TType.LIST:
14186 
          self.success = []
8590 kshitij.so 14187 
          (_etype270, _size267) = iprot.readListBegin()
14188 
          for _i271 in xrange(_size267):
14189 
            _elem272 = Item()
14190 
            _elem272.read(iprot)
14191 
            self.success.append(_elem272)
5944 mandeep.dh 14192 
          iprot.readListEnd()
14193 
        else:
14194 
          iprot.skip(ftype)
14195 
      else:
14196 
        iprot.skip(ftype)
14197 
      iprot.readFieldEnd()
14198 
    iprot.readStructEnd()
14199 
 
14200 
  def write(self, oprot):
14201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14203 
      return
14204 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14205 
    if self.success is not None:
14206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14208 
      for iter273 in self.success:
14209 
        iter273.write(oprot)
5944 mandeep.dh 14210 
      oprot.writeListEnd()
14211 
      oprot.writeFieldEnd()
14212 
    oprot.writeFieldStop()
14213 
    oprot.writeStructEnd()
14214 
 
14215 
  def validate(self):
14216 
    return
14217 
 
14218 
 
14219 
  def __repr__(self):
14220 
    L = ['%s=%r' % (key, value)
14221 
      for key, value in self.__dict__.iteritems()]
14222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14223 
 
14224 
  def __eq__(self, other):
14225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14226 
 
14227 
  def __ne__(self, other):
14228 
    return not (self == other)
14229 
 
14230 
class getSimilarItemsCatalogIds_args:
14231 
  """
14232 
  Attributes:
14233 
   - beginIndex
14234 
   - totalItems
14235 
   - itemId
14236 
  """
14237 
 
14238 
  thrift_spec = (
14239 
    None, # 0
14240 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14241 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14242 
    (3, TType.I64, 'itemId', None, None, ), # 3
14243 
  )
14244 
 
14245 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
14246 
    self.beginIndex = beginIndex
14247 
    self.totalItems = totalItems
14248 
    self.itemId = itemId
14249 
 
14250 
  def read(self, iprot):
14251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14253 
      return
14254 
    iprot.readStructBegin()
14255 
    while True:
14256 
      (fname, ftype, fid) = iprot.readFieldBegin()
14257 
      if ftype == TType.STOP:
14258 
        break
14259 
      if fid == 1:
14260 
        if ftype == TType.I64:
14261 
          self.beginIndex = iprot.readI64();
14262 
        else:
14263 
          iprot.skip(ftype)
14264 
      elif fid == 2:
14265 
        if ftype == TType.I64:
14266 
          self.totalItems = iprot.readI64();
14267 
        else:
14268 
          iprot.skip(ftype)
14269 
      elif fid == 3:
14270 
        if ftype == TType.I64:
14271 
          self.itemId = iprot.readI64();
14272 
        else:
14273 
          iprot.skip(ftype)
14274 
      else:
14275 
        iprot.skip(ftype)
14276 
      iprot.readFieldEnd()
14277 
    iprot.readStructEnd()
14278 
 
14279 
  def write(self, oprot):
14280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14282 
      return
14283 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
14284 
    if self.beginIndex is not None:
14285 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14286 
      oprot.writeI64(self.beginIndex)
14287 
      oprot.writeFieldEnd()
14288 
    if self.totalItems is not None:
14289 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14290 
      oprot.writeI64(self.totalItems)
14291 
      oprot.writeFieldEnd()
14292 
    if self.itemId is not None:
14293 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
14294 
      oprot.writeI64(self.itemId)
14295 
      oprot.writeFieldEnd()
14296 
    oprot.writeFieldStop()
14297 
    oprot.writeStructEnd()
14298 
 
14299 
  def validate(self):
14300 
    return
14301 
 
14302 
 
14303 
  def __repr__(self):
14304 
    L = ['%s=%r' % (key, value)
14305 
      for key, value in self.__dict__.iteritems()]
14306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14307 
 
14308 
  def __eq__(self, other):
14309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14310 
 
14311 
  def __ne__(self, other):
14312 
    return not (self == other)
14313 
 
14314 
class getSimilarItemsCatalogIds_result:
14315 
  """
14316 
  Attributes:
14317 
   - success
14318 
  """
14319 
 
14320 
  thrift_spec = (
14321 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14322 
  )
14323 
 
14324 
  def __init__(self, success=None,):
14325 
    self.success = success
14326 
 
14327 
  def read(self, iprot):
14328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14330 
      return
14331 
    iprot.readStructBegin()
14332 
    while True:
14333 
      (fname, ftype, fid) = iprot.readFieldBegin()
14334 
      if ftype == TType.STOP:
14335 
        break
14336 
      if fid == 0:
14337 
        if ftype == TType.LIST:
14338 
          self.success = []
8590 kshitij.so 14339 
          (_etype277, _size274) = iprot.readListBegin()
14340 
          for _i278 in xrange(_size274):
14341 
            _elem279 = iprot.readI64();
14342 
            self.success.append(_elem279)
5944 mandeep.dh 14343 
          iprot.readListEnd()
14344 
        else:
14345 
          iprot.skip(ftype)
14346 
      else:
14347 
        iprot.skip(ftype)
14348 
      iprot.readFieldEnd()
14349 
    iprot.readStructEnd()
14350 
 
14351 
  def write(self, oprot):
14352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14354 
      return
14355 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
14356 
    if self.success is not None:
14357 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14358 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 14359 
      for iter280 in self.success:
14360 
        oprot.writeI64(iter280)
5944 mandeep.dh 14361 
      oprot.writeListEnd()
14362 
      oprot.writeFieldEnd()
14363 
    oprot.writeFieldStop()
14364 
    oprot.writeStructEnd()
14365 
 
14366 
  def validate(self):
14367 
    return
14368 
 
14369 
 
14370 
  def __repr__(self):
14371 
    L = ['%s=%r' % (key, value)
14372 
      for key, value in self.__dict__.iteritems()]
14373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14374 
 
14375 
  def __eq__(self, other):
14376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14377 
 
14378 
  def __ne__(self, other):
14379 
    return not (self == other)
14380 
 
14381 
class addProductNotification_args:
14382 
  """
14383 
  Attributes:
14384 
   - itemId
14385 
   - email
14386 
  """
14387 
 
14388 
  thrift_spec = None
14389 
  def __init__(self, itemId=None, email=None,):
14390 
    self.itemId = itemId
14391 
    self.email = email
14392 
 
14393 
  def read(self, iprot):
14394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14396 
      return
14397 
    iprot.readStructBegin()
14398 
    while True:
14399 
      (fname, ftype, fid) = iprot.readFieldBegin()
14400 
      if ftype == TType.STOP:
14401 
        break
14402 
      if fid == -1:
14403 
        if ftype == TType.I64:
14404 
          self.itemId = iprot.readI64();
14405 
        else:
14406 
          iprot.skip(ftype)
14407 
      elif fid == -2:
14408 
        if ftype == TType.STRING:
14409 
          self.email = iprot.readString();
14410 
        else:
14411 
          iprot.skip(ftype)
14412 
      else:
14413 
        iprot.skip(ftype)
14414 
      iprot.readFieldEnd()
14415 
    iprot.readStructEnd()
14416 
 
14417 
  def write(self, oprot):
14418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14420 
      return
14421 
    oprot.writeStructBegin('addProductNotification_args')
14422 
    if self.email is not None:
14423 
      oprot.writeFieldBegin('email', TType.STRING, -2)
14424 
      oprot.writeString(self.email)
14425 
      oprot.writeFieldEnd()
14426 
    if self.itemId is not None:
14427 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
14428 
      oprot.writeI64(self.itemId)
14429 
      oprot.writeFieldEnd()
14430 
    oprot.writeFieldStop()
14431 
    oprot.writeStructEnd()
14432 
 
14433 
  def validate(self):
14434 
    return
14435 
 
14436 
 
14437 
  def __repr__(self):
14438 
    L = ['%s=%r' % (key, value)
14439 
      for key, value in self.__dict__.iteritems()]
14440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14441 
 
14442 
  def __eq__(self, other):
14443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14444 
 
14445 
  def __ne__(self, other):
14446 
    return not (self == other)
14447 
 
14448 
class addProductNotification_result:
14449 
  """
14450 
  Attributes:
14451 
   - success
14452 
  """
14453 
 
14454 
  thrift_spec = (
14455 
    (0, TType.BOOL, 'success', None, None, ), # 0
14456 
  )
14457 
 
14458 
  def __init__(self, success=None,):
14459 
    self.success = success
14460 
 
14461 
  def read(self, iprot):
14462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14464 
      return
14465 
    iprot.readStructBegin()
14466 
    while True:
14467 
      (fname, ftype, fid) = iprot.readFieldBegin()
14468 
      if ftype == TType.STOP:
14469 
        break
14470 
      if fid == 0:
14471 
        if ftype == TType.BOOL:
14472 
          self.success = iprot.readBool();
14473 
        else:
14474 
          iprot.skip(ftype)
14475 
      else:
14476 
        iprot.skip(ftype)
14477 
      iprot.readFieldEnd()
14478 
    iprot.readStructEnd()
14479 
 
14480 
  def write(self, oprot):
14481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14483 
      return
14484 
    oprot.writeStructBegin('addProductNotification_result')
14485 
    if self.success is not None:
14486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14487 
      oprot.writeBool(self.success)
14488 
      oprot.writeFieldEnd()
14489 
    oprot.writeFieldStop()
14490 
    oprot.writeStructEnd()
14491 
 
14492 
  def validate(self):
14493 
    return
14494 
 
14495 
 
14496 
  def __repr__(self):
14497 
    L = ['%s=%r' % (key, value)
14498 
      for key, value in self.__dict__.iteritems()]
14499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14500 
 
14501 
  def __eq__(self, other):
14502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14503 
 
14504 
  def __ne__(self, other):
14505 
    return not (self == other)
14506 
 
14507 
class sendProductNotifications_args:
14508 
 
14509 
  thrift_spec = (
14510 
  )
14511 
 
14512 
  def read(self, iprot):
14513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14515 
      return
14516 
    iprot.readStructBegin()
14517 
    while True:
14518 
      (fname, ftype, fid) = iprot.readFieldBegin()
14519 
      if ftype == TType.STOP:
14520 
        break
14521 
      else:
14522 
        iprot.skip(ftype)
14523 
      iprot.readFieldEnd()
14524 
    iprot.readStructEnd()
14525 
 
14526 
  def write(self, oprot):
14527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14529 
      return
14530 
    oprot.writeStructBegin('sendProductNotifications_args')
14531 
    oprot.writeFieldStop()
14532 
    oprot.writeStructEnd()
14533 
 
14534 
  def validate(self):
14535 
    return
14536 
 
14537 
 
14538 
  def __repr__(self):
14539 
    L = ['%s=%r' % (key, value)
14540 
      for key, value in self.__dict__.iteritems()]
14541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14542 
 
14543 
  def __eq__(self, other):
14544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14545 
 
14546 
  def __ne__(self, other):
14547 
    return not (self == other)
14548 
 
14549 
class sendProductNotifications_result:
14550 
  """
14551 
  Attributes:
14552 
   - success
14553 
  """
14554 
 
14555 
  thrift_spec = (
14556 
    (0, TType.BOOL, 'success', None, None, ), # 0
14557 
  )
14558 
 
14559 
  def __init__(self, success=None,):
14560 
    self.success = success
14561 
 
14562 
  def read(self, iprot):
14563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14565 
      return
14566 
    iprot.readStructBegin()
14567 
    while True:
14568 
      (fname, ftype, fid) = iprot.readFieldBegin()
14569 
      if ftype == TType.STOP:
14570 
        break
14571 
      if fid == 0:
14572 
        if ftype == TType.BOOL:
14573 
          self.success = iprot.readBool();
14574 
        else:
14575 
          iprot.skip(ftype)
14576 
      else:
14577 
        iprot.skip(ftype)
14578 
      iprot.readFieldEnd()
14579 
    iprot.readStructEnd()
14580 
 
14581 
  def write(self, oprot):
14582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14584 
      return
14585 
    oprot.writeStructBegin('sendProductNotifications_result')
14586 
    if self.success is not None:
14587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14588 
      oprot.writeBool(self.success)
14589 
      oprot.writeFieldEnd()
14590 
    oprot.writeFieldStop()
14591 
    oprot.writeStructEnd()
14592 
 
14593 
  def validate(self):
14594 
    return
14595 
 
14596 
 
14597 
  def __repr__(self):
14598 
    L = ['%s=%r' % (key, value)
14599 
      for key, value in self.__dict__.iteritems()]
14600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14601 
 
14602 
  def __eq__(self, other):
14603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14604 
 
14605 
  def __ne__(self, other):
14606 
    return not (self == other)
14607 
 
14608 
class getAllBrandsByCategory_args:
14609 
  """
14610 
  Attributes:
14611 
   - categoryId
14612 
  """
14613 
 
14614 
  thrift_spec = (
14615 
    None, # 0
14616 
    (1, TType.I64, 'categoryId', None, None, ), # 1
14617 
  )
14618 
 
14619 
  def __init__(self, categoryId=None,):
14620 
    self.categoryId = categoryId
14621 
 
14622 
  def read(self, iprot):
14623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14625 
      return
14626 
    iprot.readStructBegin()
14627 
    while True:
14628 
      (fname, ftype, fid) = iprot.readFieldBegin()
14629 
      if ftype == TType.STOP:
14630 
        break
14631 
      if fid == 1:
14632 
        if ftype == TType.I64:
14633 
          self.categoryId = iprot.readI64();
14634 
        else:
14635 
          iprot.skip(ftype)
14636 
      else:
14637 
        iprot.skip(ftype)
14638 
      iprot.readFieldEnd()
14639 
    iprot.readStructEnd()
14640 
 
14641 
  def write(self, oprot):
14642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14644 
      return
14645 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
14646 
    if self.categoryId is not None:
14647 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
14648 
      oprot.writeI64(self.categoryId)
14649 
      oprot.writeFieldEnd()
14650 
    oprot.writeFieldStop()
14651 
    oprot.writeStructEnd()
14652 
 
14653 
  def validate(self):
14654 
    return
14655 
 
14656 
 
14657 
  def __repr__(self):
14658 
    L = ['%s=%r' % (key, value)
14659 
      for key, value in self.__dict__.iteritems()]
14660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14661 
 
14662 
  def __eq__(self, other):
14663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14664 
 
14665 
  def __ne__(self, other):
14666 
    return not (self == other)
14667 
 
14668 
class getAllBrandsByCategory_result:
14669 
  """
14670 
  Attributes:
14671 
   - success
14672 
  """
14673 
 
14674 
  thrift_spec = (
14675 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14676 
  )
14677 
 
14678 
  def __init__(self, success=None,):
14679 
    self.success = success
14680 
 
14681 
  def read(self, iprot):
14682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14684 
      return
14685 
    iprot.readStructBegin()
14686 
    while True:
14687 
      (fname, ftype, fid) = iprot.readFieldBegin()
14688 
      if ftype == TType.STOP:
14689 
        break
14690 
      if fid == 0:
14691 
        if ftype == TType.LIST:
14692 
          self.success = []
8590 kshitij.so 14693 
          (_etype284, _size281) = iprot.readListBegin()
14694 
          for _i285 in xrange(_size281):
14695 
            _elem286 = iprot.readString();
14696 
            self.success.append(_elem286)
5944 mandeep.dh 14697 
          iprot.readListEnd()
14698 
        else:
14699 
          iprot.skip(ftype)
14700 
      else:
14701 
        iprot.skip(ftype)
14702 
      iprot.readFieldEnd()
14703 
    iprot.readStructEnd()
14704 
 
14705 
  def write(self, oprot):
14706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14708 
      return
14709 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
14710 
    if self.success is not None:
14711 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14712 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14713 
      for iter287 in self.success:
14714 
        oprot.writeString(iter287)
5944 mandeep.dh 14715 
      oprot.writeListEnd()
14716 
      oprot.writeFieldEnd()
14717 
    oprot.writeFieldStop()
14718 
    oprot.writeStructEnd()
14719 
 
14720 
  def validate(self):
14721 
    return
14722 
 
14723 
 
14724 
  def __repr__(self):
14725 
    L = ['%s=%r' % (key, value)
14726 
      for key, value in self.__dict__.iteritems()]
14727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14728 
 
14729 
  def __eq__(self, other):
14730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14731 
 
14732 
  def __ne__(self, other):
14733 
    return not (self == other)
14734 
 
14735 
class getAllBrands_args:
14736 
 
14737 
  thrift_spec = (
14738 
  )
14739 
 
14740 
  def read(self, iprot):
14741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14743 
      return
14744 
    iprot.readStructBegin()
14745 
    while True:
14746 
      (fname, ftype, fid) = iprot.readFieldBegin()
14747 
      if ftype == TType.STOP:
14748 
        break
14749 
      else:
14750 
        iprot.skip(ftype)
14751 
      iprot.readFieldEnd()
14752 
    iprot.readStructEnd()
14753 
 
14754 
  def write(self, oprot):
14755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14757 
      return
14758 
    oprot.writeStructBegin('getAllBrands_args')
14759 
    oprot.writeFieldStop()
14760 
    oprot.writeStructEnd()
14761 
 
14762 
  def validate(self):
14763 
    return
14764 
 
14765 
 
14766 
  def __repr__(self):
14767 
    L = ['%s=%r' % (key, value)
14768 
      for key, value in self.__dict__.iteritems()]
14769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14770 
 
14771 
  def __eq__(self, other):
14772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14773 
 
14774 
  def __ne__(self, other):
14775 
    return not (self == other)
14776 
 
14777 
class getAllBrands_result:
14778 
  """
14779 
  Attributes:
14780 
   - success
14781 
  """
14782 
 
14783 
  thrift_spec = (
14784 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14785 
  )
14786 
 
14787 
  def __init__(self, success=None,):
14788 
    self.success = success
14789 
 
14790 
  def read(self, iprot):
14791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14793 
      return
14794 
    iprot.readStructBegin()
14795 
    while True:
14796 
      (fname, ftype, fid) = iprot.readFieldBegin()
14797 
      if ftype == TType.STOP:
14798 
        break
14799 
      if fid == 0:
14800 
        if ftype == TType.LIST:
14801 
          self.success = []
8590 kshitij.so 14802 
          (_etype291, _size288) = iprot.readListBegin()
14803 
          for _i292 in xrange(_size288):
14804 
            _elem293 = iprot.readString();
14805 
            self.success.append(_elem293)
5944 mandeep.dh 14806 
          iprot.readListEnd()
14807 
        else:
14808 
          iprot.skip(ftype)
14809 
      else:
14810 
        iprot.skip(ftype)
14811 
      iprot.readFieldEnd()
14812 
    iprot.readStructEnd()
14813 
 
14814 
  def write(self, oprot):
14815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14817 
      return
14818 
    oprot.writeStructBegin('getAllBrands_result')
14819 
    if self.success is not None:
14820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14821 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14822 
      for iter294 in self.success:
14823 
        oprot.writeString(iter294)
5944 mandeep.dh 14824 
      oprot.writeListEnd()
14825 
      oprot.writeFieldEnd()
14826 
    oprot.writeFieldStop()
14827 
    oprot.writeStructEnd()
14828 
 
14829 
  def validate(self):
14830 
    return
14831 
 
14832 
 
14833 
  def __repr__(self):
14834 
    L = ['%s=%r' % (key, value)
14835 
      for key, value in self.__dict__.iteritems()]
14836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14837 
 
14838 
  def __eq__(self, other):
14839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14840 
 
14841 
  def __ne__(self, other):
14842 
    return not (self == other)
14843 
 
14844 
class getAllSources_args:
14845 
 
14846 
  thrift_spec = (
14847 
  )
14848 
 
14849 
  def read(self, iprot):
14850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14852 
      return
14853 
    iprot.readStructBegin()
14854 
    while True:
14855 
      (fname, ftype, fid) = iprot.readFieldBegin()
14856 
      if ftype == TType.STOP:
14857 
        break
14858 
      else:
14859 
        iprot.skip(ftype)
14860 
      iprot.readFieldEnd()
14861 
    iprot.readStructEnd()
14862 
 
14863 
  def write(self, oprot):
14864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14866 
      return
14867 
    oprot.writeStructBegin('getAllSources_args')
14868 
    oprot.writeFieldStop()
14869 
    oprot.writeStructEnd()
14870 
 
14871 
  def validate(self):
14872 
    return
14873 
 
14874 
 
14875 
  def __repr__(self):
14876 
    L = ['%s=%r' % (key, value)
14877 
      for key, value in self.__dict__.iteritems()]
14878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14879 
 
14880 
  def __eq__(self, other):
14881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14882 
 
14883 
  def __ne__(self, other):
14884 
    return not (self == other)
14885 
 
14886 
class getAllSources_result:
14887 
  """
14888 
  Attributes:
14889 
   - success
14890 
  """
14891 
 
14892 
  thrift_spec = (
14893 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
14894 
  )
14895 
 
14896 
  def __init__(self, success=None,):
14897 
    self.success = success
14898 
 
14899 
  def read(self, iprot):
14900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14902 
      return
14903 
    iprot.readStructBegin()
14904 
    while True:
14905 
      (fname, ftype, fid) = iprot.readFieldBegin()
14906 
      if ftype == TType.STOP:
14907 
        break
14908 
      if fid == 0:
14909 
        if ftype == TType.LIST:
14910 
          self.success = []
8590 kshitij.so 14911 
          (_etype298, _size295) = iprot.readListBegin()
14912 
          for _i299 in xrange(_size295):
14913 
            _elem300 = Source()
14914 
            _elem300.read(iprot)
14915 
            self.success.append(_elem300)
5944 mandeep.dh 14916 
          iprot.readListEnd()
14917 
        else:
14918 
          iprot.skip(ftype)
14919 
      else:
14920 
        iprot.skip(ftype)
14921 
      iprot.readFieldEnd()
14922 
    iprot.readStructEnd()
14923 
 
14924 
  def write(self, oprot):
14925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14927 
      return
14928 
    oprot.writeStructBegin('getAllSources_result')
14929 
    if self.success is not None:
14930 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14931 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14932 
      for iter301 in self.success:
14933 
        iter301.write(oprot)
5944 mandeep.dh 14934 
      oprot.writeListEnd()
14935 
      oprot.writeFieldEnd()
14936 
    oprot.writeFieldStop()
14937 
    oprot.writeStructEnd()
14938 
 
14939 
  def validate(self):
14940 
    return
14941 
 
14942 
 
14943 
  def __repr__(self):
14944 
    L = ['%s=%r' % (key, value)
14945 
      for key, value in self.__dict__.iteritems()]
14946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14947 
 
14948 
  def __eq__(self, other):
14949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14950 
 
14951 
  def __ne__(self, other):
14952 
    return not (self == other)
14953 
 
14954 
class getItemPricingBySource_args:
14955 
  """
14956 
  Attributes:
14957 
   - itemId
14958 
   - sourceId
14959 
  """
14960 
 
14961 
  thrift_spec = (
14962 
    None, # 0
14963 
    (1, TType.I64, 'itemId', None, None, ), # 1
14964 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14965 
  )
14966 
 
14967 
  def __init__(self, itemId=None, sourceId=None,):
14968 
    self.itemId = itemId
14969 
    self.sourceId = sourceId
14970 
 
14971 
  def read(self, iprot):
14972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14974 
      return
14975 
    iprot.readStructBegin()
14976 
    while True:
14977 
      (fname, ftype, fid) = iprot.readFieldBegin()
14978 
      if ftype == TType.STOP:
14979 
        break
14980 
      if fid == 1:
14981 
        if ftype == TType.I64:
14982 
          self.itemId = iprot.readI64();
14983 
        else:
14984 
          iprot.skip(ftype)
14985 
      elif fid == 2:
14986 
        if ftype == TType.I64:
14987 
          self.sourceId = iprot.readI64();
14988 
        else:
14989 
          iprot.skip(ftype)
14990 
      else:
14991 
        iprot.skip(ftype)
14992 
      iprot.readFieldEnd()
14993 
    iprot.readStructEnd()
14994 
 
14995 
  def write(self, oprot):
14996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14998 
      return
14999 
    oprot.writeStructBegin('getItemPricingBySource_args')
15000 
    if self.itemId is not None:
15001 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15002 
      oprot.writeI64(self.itemId)
15003 
      oprot.writeFieldEnd()
15004 
    if self.sourceId is not None:
15005 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15006 
      oprot.writeI64(self.sourceId)
15007 
      oprot.writeFieldEnd()
15008 
    oprot.writeFieldStop()
15009 
    oprot.writeStructEnd()
15010 
 
15011 
  def validate(self):
15012 
    return
15013 
 
15014 
 
15015 
  def __repr__(self):
15016 
    L = ['%s=%r' % (key, value)
15017 
      for key, value in self.__dict__.iteritems()]
15018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15019 
 
15020 
  def __eq__(self, other):
15021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15022 
 
15023 
  def __ne__(self, other):
15024 
    return not (self == other)
15025 
 
15026 
class getItemPricingBySource_result:
15027 
  """
15028 
  Attributes:
15029 
   - success
15030 
   - cex
15031 
  """
15032 
 
15033 
  thrift_spec = (
15034 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15035 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15036 
  )
15037 
 
15038 
  def __init__(self, success=None, cex=None,):
15039 
    self.success = success
15040 
    self.cex = cex
15041 
 
15042 
  def read(self, iprot):
15043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15045 
      return
15046 
    iprot.readStructBegin()
15047 
    while True:
15048 
      (fname, ftype, fid) = iprot.readFieldBegin()
15049 
      if ftype == TType.STOP:
15050 
        break
15051 
      if fid == 0:
15052 
        if ftype == TType.STRUCT:
15053 
          self.success = SourceItemPricing()
15054 
          self.success.read(iprot)
15055 
        else:
15056 
          iprot.skip(ftype)
15057 
      elif fid == 1:
15058 
        if ftype == TType.STRUCT:
15059 
          self.cex = CatalogServiceException()
15060 
          self.cex.read(iprot)
15061 
        else:
15062 
          iprot.skip(ftype)
15063 
      else:
15064 
        iprot.skip(ftype)
15065 
      iprot.readFieldEnd()
15066 
    iprot.readStructEnd()
15067 
 
15068 
  def write(self, oprot):
15069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15071 
      return
15072 
    oprot.writeStructBegin('getItemPricingBySource_result')
15073 
    if self.success is not None:
15074 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15075 
      self.success.write(oprot)
15076 
      oprot.writeFieldEnd()
15077 
    if self.cex is not None:
15078 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15079 
      self.cex.write(oprot)
15080 
      oprot.writeFieldEnd()
15081 
    oprot.writeFieldStop()
15082 
    oprot.writeStructEnd()
15083 
 
15084 
  def validate(self):
15085 
    return
15086 
 
15087 
 
15088 
  def __repr__(self):
15089 
    L = ['%s=%r' % (key, value)
15090 
      for key, value in self.__dict__.iteritems()]
15091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15092 
 
15093 
  def __eq__(self, other):
15094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15095 
 
15096 
  def __ne__(self, other):
15097 
    return not (self == other)
15098 
 
15099 
class addSourceItemPricing_args:
15100 
  """
15101 
  Attributes:
15102 
   - sourceItemPricing
15103 
  """
15104 
 
15105 
  thrift_spec = (
15106 
    None, # 0
15107 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15108 
  )
15109 
 
15110 
  def __init__(self, sourceItemPricing=None,):
15111 
    self.sourceItemPricing = sourceItemPricing
15112 
 
15113 
  def read(self, iprot):
15114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15116 
      return
15117 
    iprot.readStructBegin()
15118 
    while True:
15119 
      (fname, ftype, fid) = iprot.readFieldBegin()
15120 
      if ftype == TType.STOP:
15121 
        break
15122 
      if fid == 1:
15123 
        if ftype == TType.STRUCT:
15124 
          self.sourceItemPricing = SourceItemPricing()
15125 
          self.sourceItemPricing.read(iprot)
15126 
        else:
15127 
          iprot.skip(ftype)
15128 
      else:
15129 
        iprot.skip(ftype)
15130 
      iprot.readFieldEnd()
15131 
    iprot.readStructEnd()
15132 
 
15133 
  def write(self, oprot):
15134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15136 
      return
15137 
    oprot.writeStructBegin('addSourceItemPricing_args')
15138 
    if self.sourceItemPricing is not None:
15139 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15140 
      self.sourceItemPricing.write(oprot)
15141 
      oprot.writeFieldEnd()
15142 
    oprot.writeFieldStop()
15143 
    oprot.writeStructEnd()
15144 
 
15145 
  def validate(self):
15146 
    return
15147 
 
15148 
 
15149 
  def __repr__(self):
15150 
    L = ['%s=%r' % (key, value)
15151 
      for key, value in self.__dict__.iteritems()]
15152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15153 
 
15154 
  def __eq__(self, other):
15155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15156 
 
15157 
  def __ne__(self, other):
15158 
    return not (self == other)
15159 
 
15160 
class addSourceItemPricing_result:
15161 
  """
15162 
  Attributes:
15163 
   - cex
15164 
  """
15165 
 
15166 
  thrift_spec = (
15167 
    None, # 0
15168 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15169 
  )
15170 
 
15171 
  def __init__(self, cex=None,):
15172 
    self.cex = cex
15173 
 
15174 
  def read(self, iprot):
15175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15177 
      return
15178 
    iprot.readStructBegin()
15179 
    while True:
15180 
      (fname, ftype, fid) = iprot.readFieldBegin()
15181 
      if ftype == TType.STOP:
15182 
        break
15183 
      if fid == 1:
15184 
        if ftype == TType.STRUCT:
15185 
          self.cex = CatalogServiceException()
15186 
          self.cex.read(iprot)
15187 
        else:
15188 
          iprot.skip(ftype)
15189 
      else:
15190 
        iprot.skip(ftype)
15191 
      iprot.readFieldEnd()
15192 
    iprot.readStructEnd()
15193 
 
15194 
  def write(self, oprot):
15195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15197 
      return
15198 
    oprot.writeStructBegin('addSourceItemPricing_result')
15199 
    if self.cex is not None:
15200 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15201 
      self.cex.write(oprot)
15202 
      oprot.writeFieldEnd()
15203 
    oprot.writeFieldStop()
15204 
    oprot.writeStructEnd()
15205 
 
15206 
  def validate(self):
15207 
    return
15208 
 
15209 
 
15210 
  def __repr__(self):
15211 
    L = ['%s=%r' % (key, value)
15212 
      for key, value in self.__dict__.iteritems()]
15213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15214 
 
15215 
  def __eq__(self, other):
15216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15217 
 
15218 
  def __ne__(self, other):
15219 
    return not (self == other)
15220 
 
15221 
class getAllSourcePricing_args:
15222 
  """
15223 
  Attributes:
15224 
   - itemId
15225 
  """
15226 
 
15227 
  thrift_spec = (
15228 
    None, # 0
15229 
    (1, TType.I64, 'itemId', None, None, ), # 1
15230 
  )
15231 
 
15232 
  def __init__(self, itemId=None,):
15233 
    self.itemId = itemId
15234 
 
15235 
  def read(self, iprot):
15236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15238 
      return
15239 
    iprot.readStructBegin()
15240 
    while True:
15241 
      (fname, ftype, fid) = iprot.readFieldBegin()
15242 
      if ftype == TType.STOP:
15243 
        break
15244 
      if fid == 1:
15245 
        if ftype == TType.I64:
15246 
          self.itemId = iprot.readI64();
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      else:
15250 
        iprot.skip(ftype)
15251 
      iprot.readFieldEnd()
15252 
    iprot.readStructEnd()
15253 
 
15254 
  def write(self, oprot):
15255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15257 
      return
15258 
    oprot.writeStructBegin('getAllSourcePricing_args')
15259 
    if self.itemId is not None:
15260 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15261 
      oprot.writeI64(self.itemId)
15262 
      oprot.writeFieldEnd()
15263 
    oprot.writeFieldStop()
15264 
    oprot.writeStructEnd()
15265 
 
15266 
  def validate(self):
15267 
    return
15268 
 
15269 
 
15270 
  def __repr__(self):
15271 
    L = ['%s=%r' % (key, value)
15272 
      for key, value in self.__dict__.iteritems()]
15273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15274 
 
15275 
  def __eq__(self, other):
15276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15277 
 
15278 
  def __ne__(self, other):
15279 
    return not (self == other)
15280 
 
15281 
class getAllSourcePricing_result:
15282 
  """
15283 
  Attributes:
15284 
   - success
15285 
   - cex
15286 
  """
15287 
 
15288 
  thrift_spec = (
15289 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
15290 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15291 
  )
15292 
 
15293 
  def __init__(self, success=None, cex=None,):
15294 
    self.success = success
15295 
    self.cex = cex
15296 
 
15297 
  def read(self, iprot):
15298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15300 
      return
15301 
    iprot.readStructBegin()
15302 
    while True:
15303 
      (fname, ftype, fid) = iprot.readFieldBegin()
15304 
      if ftype == TType.STOP:
15305 
        break
15306 
      if fid == 0:
15307 
        if ftype == TType.LIST:
15308 
          self.success = []
8590 kshitij.so 15309 
          (_etype305, _size302) = iprot.readListBegin()
15310 
          for _i306 in xrange(_size302):
15311 
            _elem307 = SourceItemPricing()
15312 
            _elem307.read(iprot)
15313 
            self.success.append(_elem307)
5944 mandeep.dh 15314 
          iprot.readListEnd()
15315 
        else:
15316 
          iprot.skip(ftype)
15317 
      elif fid == 1:
15318 
        if ftype == TType.STRUCT:
15319 
          self.cex = CatalogServiceException()
15320 
          self.cex.read(iprot)
15321 
        else:
15322 
          iprot.skip(ftype)
15323 
      else:
15324 
        iprot.skip(ftype)
15325 
      iprot.readFieldEnd()
15326 
    iprot.readStructEnd()
15327 
 
15328 
  def write(self, oprot):
15329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15331 
      return
15332 
    oprot.writeStructBegin('getAllSourcePricing_result')
15333 
    if self.success is not None:
15334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15336 
      for iter308 in self.success:
15337 
        iter308.write(oprot)
5944 mandeep.dh 15338 
      oprot.writeListEnd()
15339 
      oprot.writeFieldEnd()
15340 
    if self.cex is not None:
15341 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15342 
      self.cex.write(oprot)
15343 
      oprot.writeFieldEnd()
15344 
    oprot.writeFieldStop()
15345 
    oprot.writeStructEnd()
15346 
 
15347 
  def validate(self):
15348 
    return
15349 
 
15350 
 
15351 
  def __repr__(self):
15352 
    L = ['%s=%r' % (key, value)
15353 
      for key, value in self.__dict__.iteritems()]
15354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15355 
 
15356 
  def __eq__(self, other):
15357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15358 
 
15359 
  def __ne__(self, other):
15360 
    return not (self == other)
15361 
 
15362 
class getItemForSource_args:
15363 
  """
15364 
  Attributes:
15365 
   - item_id
15366 
   - sourceId
15367 
  """
15368 
 
15369 
  thrift_spec = (
15370 
    None, # 0
15371 
    (1, TType.I64, 'item_id', None, None, ), # 1
15372 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15373 
  )
15374 
 
15375 
  def __init__(self, item_id=None, sourceId=None,):
15376 
    self.item_id = item_id
15377 
    self.sourceId = sourceId
15378 
 
15379 
  def read(self, iprot):
15380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15382 
      return
15383 
    iprot.readStructBegin()
15384 
    while True:
15385 
      (fname, ftype, fid) = iprot.readFieldBegin()
15386 
      if ftype == TType.STOP:
15387 
        break
15388 
      if fid == 1:
15389 
        if ftype == TType.I64:
15390 
          self.item_id = iprot.readI64();
15391 
        else:
15392 
          iprot.skip(ftype)
15393 
      elif fid == 2:
15394 
        if ftype == TType.I64:
15395 
          self.sourceId = iprot.readI64();
15396 
        else:
15397 
          iprot.skip(ftype)
15398 
      else:
15399 
        iprot.skip(ftype)
15400 
      iprot.readFieldEnd()
15401 
    iprot.readStructEnd()
15402 
 
15403 
  def write(self, oprot):
15404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15406 
      return
15407 
    oprot.writeStructBegin('getItemForSource_args')
15408 
    if self.item_id is not None:
15409 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
15410 
      oprot.writeI64(self.item_id)
15411 
      oprot.writeFieldEnd()
15412 
    if self.sourceId is not None:
15413 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15414 
      oprot.writeI64(self.sourceId)
15415 
      oprot.writeFieldEnd()
15416 
    oprot.writeFieldStop()
15417 
    oprot.writeStructEnd()
15418 
 
15419 
  def validate(self):
15420 
    return
15421 
 
15422 
 
15423 
  def __repr__(self):
15424 
    L = ['%s=%r' % (key, value)
15425 
      for key, value in self.__dict__.iteritems()]
15426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15427 
 
15428 
  def __eq__(self, other):
15429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15430 
 
15431 
  def __ne__(self, other):
15432 
    return not (self == other)
15433 
 
15434 
class getItemForSource_result:
15435 
  """
15436 
  Attributes:
15437 
   - success
15438 
   - cex
15439 
  """
15440 
 
15441 
  thrift_spec = (
15442 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
15443 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15444 
  )
15445 
 
15446 
  def __init__(self, success=None, cex=None,):
15447 
    self.success = success
15448 
    self.cex = cex
15449 
 
15450 
  def read(self, iprot):
15451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15453 
      return
15454 
    iprot.readStructBegin()
15455 
    while True:
15456 
      (fname, ftype, fid) = iprot.readFieldBegin()
15457 
      if ftype == TType.STOP:
15458 
        break
15459 
      if fid == 0:
15460 
        if ftype == TType.STRUCT:
15461 
          self.success = Item()
15462 
          self.success.read(iprot)
15463 
        else:
15464 
          iprot.skip(ftype)
15465 
      elif fid == 1:
15466 
        if ftype == TType.STRUCT:
15467 
          self.cex = CatalogServiceException()
15468 
          self.cex.read(iprot)
15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      else:
15472 
        iprot.skip(ftype)
15473 
      iprot.readFieldEnd()
15474 
    iprot.readStructEnd()
15475 
 
15476 
  def write(self, oprot):
15477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15479 
      return
15480 
    oprot.writeStructBegin('getItemForSource_result')
15481 
    if self.success is not None:
15482 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15483 
      self.success.write(oprot)
15484 
      oprot.writeFieldEnd()
15485 
    if self.cex is not None:
15486 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15487 
      self.cex.write(oprot)
15488 
      oprot.writeFieldEnd()
15489 
    oprot.writeFieldStop()
15490 
    oprot.writeStructEnd()
15491 
 
15492 
  def validate(self):
15493 
    return
15494 
 
15495 
 
15496 
  def __repr__(self):
15497 
    L = ['%s=%r' % (key, value)
15498 
      for key, value in self.__dict__.iteritems()]
15499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15500 
 
15501 
  def __eq__(self, other):
15502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15503 
 
15504 
  def __ne__(self, other):
15505 
    return not (self == other)
15506 
 
15507 
class searchItemsInRange_args:
15508 
  """
15509 
  Attributes:
15510 
   - searchTerms
15511 
   - offset
15512 
   - limit
15513 
  """
15514 
 
15515 
  thrift_spec = (
15516 
    None, # 0
15517 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15518 
    (2, TType.I64, 'offset', None, None, ), # 2
15519 
    (3, TType.I64, 'limit', None, None, ), # 3
15520 
  )
15521 
 
15522 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
15523 
    self.searchTerms = searchTerms
15524 
    self.offset = offset
15525 
    self.limit = limit
15526 
 
15527 
  def read(self, iprot):
15528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15530 
      return
15531 
    iprot.readStructBegin()
15532 
    while True:
15533 
      (fname, ftype, fid) = iprot.readFieldBegin()
15534 
      if ftype == TType.STOP:
15535 
        break
15536 
      if fid == 1:
15537 
        if ftype == TType.LIST:
15538 
          self.searchTerms = []
8590 kshitij.so 15539 
          (_etype312, _size309) = iprot.readListBegin()
15540 
          for _i313 in xrange(_size309):
15541 
            _elem314 = iprot.readString();
15542 
            self.searchTerms.append(_elem314)
5944 mandeep.dh 15543 
          iprot.readListEnd()
15544 
        else:
15545 
          iprot.skip(ftype)
15546 
      elif fid == 2:
15547 
        if ftype == TType.I64:
15548 
          self.offset = iprot.readI64();
15549 
        else:
15550 
          iprot.skip(ftype)
15551 
      elif fid == 3:
15552 
        if ftype == TType.I64:
15553 
          self.limit = iprot.readI64();
15554 
        else:
15555 
          iprot.skip(ftype)
15556 
      else:
15557 
        iprot.skip(ftype)
15558 
      iprot.readFieldEnd()
15559 
    iprot.readStructEnd()
15560 
 
15561 
  def write(self, oprot):
15562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15564 
      return
15565 
    oprot.writeStructBegin('searchItemsInRange_args')
15566 
    if self.searchTerms is not None:
15567 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15568 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15569 
      for iter315 in self.searchTerms:
15570 
        oprot.writeString(iter315)
5944 mandeep.dh 15571 
      oprot.writeListEnd()
15572 
      oprot.writeFieldEnd()
15573 
    if self.offset is not None:
15574 
      oprot.writeFieldBegin('offset', TType.I64, 2)
15575 
      oprot.writeI64(self.offset)
15576 
      oprot.writeFieldEnd()
15577 
    if self.limit is not None:
15578 
      oprot.writeFieldBegin('limit', TType.I64, 3)
15579 
      oprot.writeI64(self.limit)
15580 
      oprot.writeFieldEnd()
15581 
    oprot.writeFieldStop()
15582 
    oprot.writeStructEnd()
15583 
 
15584 
  def validate(self):
15585 
    return
15586 
 
15587 
 
15588 
  def __repr__(self):
15589 
    L = ['%s=%r' % (key, value)
15590 
      for key, value in self.__dict__.iteritems()]
15591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15592 
 
15593 
  def __eq__(self, other):
15594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15595 
 
15596 
  def __ne__(self, other):
15597 
    return not (self == other)
15598 
 
15599 
class searchItemsInRange_result:
15600 
  """
15601 
  Attributes:
15602 
   - success
15603 
  """
15604 
 
15605 
  thrift_spec = (
15606 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15607 
  )
15608 
 
15609 
  def __init__(self, success=None,):
15610 
    self.success = success
15611 
 
15612 
  def read(self, iprot):
15613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15615 
      return
15616 
    iprot.readStructBegin()
15617 
    while True:
15618 
      (fname, ftype, fid) = iprot.readFieldBegin()
15619 
      if ftype == TType.STOP:
15620 
        break
15621 
      if fid == 0:
15622 
        if ftype == TType.LIST:
15623 
          self.success = []
8590 kshitij.so 15624 
          (_etype319, _size316) = iprot.readListBegin()
15625 
          for _i320 in xrange(_size316):
15626 
            _elem321 = Item()
15627 
            _elem321.read(iprot)
15628 
            self.success.append(_elem321)
5944 mandeep.dh 15629 
          iprot.readListEnd()
15630 
        else:
15631 
          iprot.skip(ftype)
15632 
      else:
15633 
        iprot.skip(ftype)
15634 
      iprot.readFieldEnd()
15635 
    iprot.readStructEnd()
15636 
 
15637 
  def write(self, oprot):
15638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15640 
      return
15641 
    oprot.writeStructBegin('searchItemsInRange_result')
15642 
    if self.success is not None:
15643 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15644 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15645 
      for iter322 in self.success:
15646 
        iter322.write(oprot)
5944 mandeep.dh 15647 
      oprot.writeListEnd()
15648 
      oprot.writeFieldEnd()
15649 
    oprot.writeFieldStop()
15650 
    oprot.writeStructEnd()
15651 
 
15652 
  def validate(self):
15653 
    return
15654 
 
15655 
 
15656 
  def __repr__(self):
15657 
    L = ['%s=%r' % (key, value)
15658 
      for key, value in self.__dict__.iteritems()]
15659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15660 
 
15661 
  def __eq__(self, other):
15662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15663 
 
15664 
  def __ne__(self, other):
15665 
    return not (self == other)
15666 
 
15667 
class getSearchResultCount_args:
15668 
  """
15669 
  Attributes:
15670 
   - searchTerms
15671 
  """
15672 
 
15673 
  thrift_spec = (
15674 
    None, # 0
15675 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15676 
  )
15677 
 
15678 
  def __init__(self, searchTerms=None,):
15679 
    self.searchTerms = searchTerms
15680 
 
15681 
  def read(self, iprot):
15682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15684 
      return
15685 
    iprot.readStructBegin()
15686 
    while True:
15687 
      (fname, ftype, fid) = iprot.readFieldBegin()
15688 
      if ftype == TType.STOP:
15689 
        break
15690 
      if fid == 1:
15691 
        if ftype == TType.LIST:
15692 
          self.searchTerms = []
8590 kshitij.so 15693 
          (_etype326, _size323) = iprot.readListBegin()
15694 
          for _i327 in xrange(_size323):
15695 
            _elem328 = iprot.readString();
15696 
            self.searchTerms.append(_elem328)
5944 mandeep.dh 15697 
          iprot.readListEnd()
15698 
        else:
15699 
          iprot.skip(ftype)
15700 
      else:
15701 
        iprot.skip(ftype)
15702 
      iprot.readFieldEnd()
15703 
    iprot.readStructEnd()
15704 
 
15705 
  def write(self, oprot):
15706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15708 
      return
15709 
    oprot.writeStructBegin('getSearchResultCount_args')
15710 
    if self.searchTerms is not None:
15711 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15712 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15713 
      for iter329 in self.searchTerms:
15714 
        oprot.writeString(iter329)
5944 mandeep.dh 15715 
      oprot.writeListEnd()
15716 
      oprot.writeFieldEnd()
15717 
    oprot.writeFieldStop()
15718 
    oprot.writeStructEnd()
15719 
 
15720 
  def validate(self):
15721 
    return
15722 
 
15723 
 
15724 
  def __repr__(self):
15725 
    L = ['%s=%r' % (key, value)
15726 
      for key, value in self.__dict__.iteritems()]
15727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15728 
 
15729 
  def __eq__(self, other):
15730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15731 
 
15732 
  def __ne__(self, other):
15733 
    return not (self == other)
15734 
 
15735 
class getSearchResultCount_result:
15736 
  """
15737 
  Attributes:
15738 
   - success
15739 
  """
15740 
 
15741 
  thrift_spec = (
15742 
    (0, TType.I32, 'success', None, None, ), # 0
15743 
  )
15744 
 
15745 
  def __init__(self, success=None,):
15746 
    self.success = success
15747 
 
15748 
  def read(self, iprot):
15749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15751 
      return
15752 
    iprot.readStructBegin()
15753 
    while True:
15754 
      (fname, ftype, fid) = iprot.readFieldBegin()
15755 
      if ftype == TType.STOP:
15756 
        break
15757 
      if fid == 0:
15758 
        if ftype == TType.I32:
15759 
          self.success = iprot.readI32();
15760 
        else:
15761 
          iprot.skip(ftype)
15762 
      else:
15763 
        iprot.skip(ftype)
15764 
      iprot.readFieldEnd()
15765 
    iprot.readStructEnd()
15766 
 
15767 
  def write(self, oprot):
15768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15770 
      return
15771 
    oprot.writeStructBegin('getSearchResultCount_result')
15772 
    if self.success is not None:
15773 
      oprot.writeFieldBegin('success', TType.I32, 0)
15774 
      oprot.writeI32(self.success)
15775 
      oprot.writeFieldEnd()
15776 
    oprot.writeFieldStop()
15777 
    oprot.writeStructEnd()
15778 
 
15779 
  def validate(self):
15780 
    return
15781 
 
15782 
 
15783 
  def __repr__(self):
15784 
    L = ['%s=%r' % (key, value)
15785 
      for key, value in self.__dict__.iteritems()]
15786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15787 
 
15788 
  def __eq__(self, other):
15789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15790 
 
15791 
  def __ne__(self, other):
15792 
    return not (self == other)
15793 
 
15794 
class getProductNotifications_args:
15795 
  """
15796 
  Attributes:
15797 
   - startDateTime
15798 
  """
15799 
 
15800 
  thrift_spec = (
15801 
    None, # 0
15802 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
15803 
  )
15804 
 
15805 
  def __init__(self, startDateTime=None,):
15806 
    self.startDateTime = startDateTime
15807 
 
15808 
  def read(self, iprot):
15809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15811 
      return
15812 
    iprot.readStructBegin()
15813 
    while True:
15814 
      (fname, ftype, fid) = iprot.readFieldBegin()
15815 
      if ftype == TType.STOP:
15816 
        break
15817 
      if fid == 1:
15818 
        if ftype == TType.I64:
15819 
          self.startDateTime = iprot.readI64();
15820 
        else:
15821 
          iprot.skip(ftype)
15822 
      else:
15823 
        iprot.skip(ftype)
15824 
      iprot.readFieldEnd()
15825 
    iprot.readStructEnd()
15826 
 
15827 
  def write(self, oprot):
15828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15830 
      return
15831 
    oprot.writeStructBegin('getProductNotifications_args')
15832 
    if self.startDateTime is not None:
15833 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
15834 
      oprot.writeI64(self.startDateTime)
15835 
      oprot.writeFieldEnd()
15836 
    oprot.writeFieldStop()
15837 
    oprot.writeStructEnd()
15838 
 
15839 
  def validate(self):
15840 
    return
15841 
 
15842 
 
15843 
  def __repr__(self):
15844 
    L = ['%s=%r' % (key, value)
15845 
      for key, value in self.__dict__.iteritems()]
15846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15847 
 
15848 
  def __eq__(self, other):
15849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15850 
 
15851 
  def __ne__(self, other):
15852 
    return not (self == other)
15853 
 
15854 
class getProductNotifications_result:
15855 
  """
15856 
  Attributes:
15857 
   - success
15858 
  """
15859 
 
15860 
  thrift_spec = (
15861 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
15862 
  )
15863 
 
15864 
  def __init__(self, success=None,):
15865 
    self.success = success
15866 
 
15867 
  def read(self, iprot):
15868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15870 
      return
15871 
    iprot.readStructBegin()
15872 
    while True:
15873 
      (fname, ftype, fid) = iprot.readFieldBegin()
15874 
      if ftype == TType.STOP:
15875 
        break
15876 
      if fid == 0:
15877 
        if ftype == TType.LIST:
15878 
          self.success = []
8590 kshitij.so 15879 
          (_etype333, _size330) = iprot.readListBegin()
15880 
          for _i334 in xrange(_size330):
15881 
            _elem335 = ProductNotificationRequest()
15882 
            _elem335.read(iprot)
15883 
            self.success.append(_elem335)
5944 mandeep.dh 15884 
          iprot.readListEnd()
15885 
        else:
15886 
          iprot.skip(ftype)
15887 
      else:
15888 
        iprot.skip(ftype)
15889 
      iprot.readFieldEnd()
15890 
    iprot.readStructEnd()
15891 
 
15892 
  def write(self, oprot):
15893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15895 
      return
15896 
    oprot.writeStructBegin('getProductNotifications_result')
15897 
    if self.success is not None:
15898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15900 
      for iter336 in self.success:
15901 
        iter336.write(oprot)
5944 mandeep.dh 15902 
      oprot.writeListEnd()
15903 
      oprot.writeFieldEnd()
15904 
    oprot.writeFieldStop()
15905 
    oprot.writeStructEnd()
15906 
 
15907 
  def validate(self):
15908 
    return
15909 
 
15910 
 
15911 
  def __repr__(self):
15912 
    L = ['%s=%r' % (key, value)
15913 
      for key, value in self.__dict__.iteritems()]
15914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15915 
 
15916 
  def __eq__(self, other):
15917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15918 
 
15919 
  def __ne__(self, other):
15920 
    return not (self == other)
15921 
 
15922 
class getProductNotificationRequestCount_args:
15923 
  """
15924 
  Attributes:
15925 
   - startDateTime
7897 amar.kumar 15926 
   - categoryId
5944 mandeep.dh 15927 
  """
15928 
 
15929 
  thrift_spec = (
15930 
    None, # 0
15931 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 15932 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 15933 
  )
15934 
 
7897 amar.kumar 15935 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 15936 
    self.startDateTime = startDateTime
7897 amar.kumar 15937 
    self.categoryId = categoryId
5944 mandeep.dh 15938 
 
15939 
  def read(self, iprot):
15940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15942 
      return
15943 
    iprot.readStructBegin()
15944 
    while True:
15945 
      (fname, ftype, fid) = iprot.readFieldBegin()
15946 
      if ftype == TType.STOP:
15947 
        break
15948 
      if fid == 1:
15949 
        if ftype == TType.I64:
15950 
          self.startDateTime = iprot.readI64();
15951 
        else:
15952 
          iprot.skip(ftype)
7897 amar.kumar 15953 
      elif fid == 2:
15954 
        if ftype == TType.I64:
15955 
          self.categoryId = iprot.readI64();
15956 
        else:
15957 
          iprot.skip(ftype)
5944 mandeep.dh 15958 
      else:
15959 
        iprot.skip(ftype)
15960 
      iprot.readFieldEnd()
15961 
    iprot.readStructEnd()
15962 
 
15963 
  def write(self, oprot):
15964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15966 
      return
15967 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
15968 
    if self.startDateTime is not None:
15969 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
15970 
      oprot.writeI64(self.startDateTime)
15971 
      oprot.writeFieldEnd()
7897 amar.kumar 15972 
    if self.categoryId is not None:
15973 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
15974 
      oprot.writeI64(self.categoryId)
15975 
      oprot.writeFieldEnd()
5944 mandeep.dh 15976 
    oprot.writeFieldStop()
15977 
    oprot.writeStructEnd()
15978 
 
15979 
  def validate(self):
15980 
    return
15981 
 
15982 
 
15983 
  def __repr__(self):
15984 
    L = ['%s=%r' % (key, value)
15985 
      for key, value in self.__dict__.iteritems()]
15986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15987 
 
15988 
  def __eq__(self, other):
15989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15990 
 
15991 
  def __ne__(self, other):
15992 
    return not (self == other)
15993 
 
15994 
class getProductNotificationRequestCount_result:
15995 
  """
15996 
  Attributes:
15997 
   - success
15998 
  """
15999 
 
16000 
  thrift_spec = (
16001 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16002 
  )
16003 
 
16004 
  def __init__(self, success=None,):
16005 
    self.success = success
16006 
 
16007 
  def read(self, iprot):
16008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16010 
      return
16011 
    iprot.readStructBegin()
16012 
    while True:
16013 
      (fname, ftype, fid) = iprot.readFieldBegin()
16014 
      if ftype == TType.STOP:
16015 
        break
16016 
      if fid == 0:
16017 
        if ftype == TType.LIST:
16018 
          self.success = []
8590 kshitij.so 16019 
          (_etype340, _size337) = iprot.readListBegin()
16020 
          for _i341 in xrange(_size337):
16021 
            _elem342 = ProductNotificationRequestCount()
16022 
            _elem342.read(iprot)
16023 
            self.success.append(_elem342)
5944 mandeep.dh 16024 
          iprot.readListEnd()
16025 
        else:
16026 
          iprot.skip(ftype)
16027 
      else:
16028 
        iprot.skip(ftype)
16029 
      iprot.readFieldEnd()
16030 
    iprot.readStructEnd()
16031 
 
16032 
  def write(self, oprot):
16033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16035 
      return
16036 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16037 
    if self.success is not None:
16038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16039 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16040 
      for iter343 in self.success:
16041 
        iter343.write(oprot)
5944 mandeep.dh 16042 
      oprot.writeListEnd()
16043 
      oprot.writeFieldEnd()
16044 
    oprot.writeFieldStop()
16045 
    oprot.writeStructEnd()
16046 
 
16047 
  def validate(self):
16048 
    return
16049 
 
16050 
 
16051 
  def __repr__(self):
16052 
    L = ['%s=%r' % (key, value)
16053 
      for key, value in self.__dict__.iteritems()]
16054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16055 
 
16056 
  def __eq__(self, other):
16057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16058 
 
16059 
  def __ne__(self, other):
16060 
    return not (self == other)
16061 
 
16062 
class addAuthorizationLog_args:
16063 
  """
16064 
  Attributes:
16065 
   - itemId
16066 
   - username
16067 
   - reason
16068 
  """
16069 
 
16070 
  thrift_spec = (
16071 
    None, # 0
16072 
    (1, TType.I64, 'itemId', None, None, ), # 1
16073 
    (2, TType.STRING, 'username', None, None, ), # 2
16074 
    (3, TType.STRING, 'reason', None, None, ), # 3
16075 
  )
16076 
 
16077 
  def __init__(self, itemId=None, username=None, reason=None,):
16078 
    self.itemId = itemId
16079 
    self.username = username
16080 
    self.reason = reason
16081 
 
16082 
  def read(self, iprot):
16083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16085 
      return
16086 
    iprot.readStructBegin()
16087 
    while True:
16088 
      (fname, ftype, fid) = iprot.readFieldBegin()
16089 
      if ftype == TType.STOP:
16090 
        break
16091 
      if fid == 1:
16092 
        if ftype == TType.I64:
16093 
          self.itemId = iprot.readI64();
16094 
        else:
16095 
          iprot.skip(ftype)
16096 
      elif fid == 2:
16097 
        if ftype == TType.STRING:
16098 
          self.username = iprot.readString();
16099 
        else:
16100 
          iprot.skip(ftype)
16101 
      elif fid == 3:
16102 
        if ftype == TType.STRING:
16103 
          self.reason = iprot.readString();
16104 
        else:
16105 
          iprot.skip(ftype)
16106 
      else:
16107 
        iprot.skip(ftype)
16108 
      iprot.readFieldEnd()
16109 
    iprot.readStructEnd()
16110 
 
16111 
  def write(self, oprot):
16112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16114 
      return
16115 
    oprot.writeStructBegin('addAuthorizationLog_args')
16116 
    if self.itemId is not None:
16117 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16118 
      oprot.writeI64(self.itemId)
16119 
      oprot.writeFieldEnd()
16120 
    if self.username is not None:
16121 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16122 
      oprot.writeString(self.username)
16123 
      oprot.writeFieldEnd()
16124 
    if self.reason is not None:
16125 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16126 
      oprot.writeString(self.reason)
16127 
      oprot.writeFieldEnd()
16128 
    oprot.writeFieldStop()
16129 
    oprot.writeStructEnd()
16130 
 
16131 
  def validate(self):
16132 
    return
16133 
 
16134 
 
16135 
  def __repr__(self):
16136 
    L = ['%s=%r' % (key, value)
16137 
      for key, value in self.__dict__.iteritems()]
16138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16139 
 
16140 
  def __eq__(self, other):
16141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16142 
 
16143 
  def __ne__(self, other):
16144 
    return not (self == other)
16145 
 
16146 
class addAuthorizationLog_result:
16147 
  """
16148 
  Attributes:
16149 
   - success
16150 
   - cex
16151 
  """
16152 
 
16153 
  thrift_spec = (
16154 
    (0, TType.BOOL, 'success', None, None, ), # 0
16155 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16156 
  )
16157 
 
16158 
  def __init__(self, success=None, cex=None,):
16159 
    self.success = success
16160 
    self.cex = cex
16161 
 
16162 
  def read(self, iprot):
16163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16165 
      return
16166 
    iprot.readStructBegin()
16167 
    while True:
16168 
      (fname, ftype, fid) = iprot.readFieldBegin()
16169 
      if ftype == TType.STOP:
16170 
        break
16171 
      if fid == 0:
16172 
        if ftype == TType.BOOL:
16173 
          self.success = iprot.readBool();
16174 
        else:
16175 
          iprot.skip(ftype)
16176 
      elif fid == 1:
16177 
        if ftype == TType.STRUCT:
16178 
          self.cex = CatalogServiceException()
16179 
          self.cex.read(iprot)
16180 
        else:
16181 
          iprot.skip(ftype)
16182 
      else:
16183 
        iprot.skip(ftype)
16184 
      iprot.readFieldEnd()
16185 
    iprot.readStructEnd()
16186 
 
16187 
  def write(self, oprot):
16188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16190 
      return
16191 
    oprot.writeStructBegin('addAuthorizationLog_result')
16192 
    if self.success is not None:
16193 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16194 
      oprot.writeBool(self.success)
16195 
      oprot.writeFieldEnd()
16196 
    if self.cex is not None:
16197 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16198 
      self.cex.write(oprot)
16199 
      oprot.writeFieldEnd()
16200 
    oprot.writeFieldStop()
16201 
    oprot.writeStructEnd()
16202 
 
16203 
  def validate(self):
16204 
    return
16205 
 
16206 
 
16207 
  def __repr__(self):
16208 
    L = ['%s=%r' % (key, value)
16209 
      for key, value in self.__dict__.iteritems()]
16210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16211 
 
16212 
  def __eq__(self, other):
16213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16214 
 
16215 
  def __ne__(self, other):
16216 
    return not (self == other)
16217 
 
16218 
class addupdateVoucherForItem_args:
16219 
  """
16220 
  Attributes:
16221 
   - catalog_item_id
16222 
   - voucherType
16223 
   - voucherAmount
16224 
  """
16225 
 
16226 
  thrift_spec = (
16227 
    None, # 0
16228 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16229 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16230 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16231 
  )
16232 
 
16233 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16234 
    self.catalog_item_id = catalog_item_id
16235 
    self.voucherType = voucherType
16236 
    self.voucherAmount = voucherAmount
16237 
 
16238 
  def read(self, iprot):
16239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16241 
      return
16242 
    iprot.readStructBegin()
16243 
    while True:
16244 
      (fname, ftype, fid) = iprot.readFieldBegin()
16245 
      if ftype == TType.STOP:
16246 
        break
16247 
      if fid == 1:
16248 
        if ftype == TType.I64:
16249 
          self.catalog_item_id = iprot.readI64();
16250 
        else:
16251 
          iprot.skip(ftype)
16252 
      elif fid == 2:
16253 
        if ftype == TType.I64:
16254 
          self.voucherType = iprot.readI64();
16255 
        else:
16256 
          iprot.skip(ftype)
16257 
      elif fid == 3:
16258 
        if ftype == TType.I64:
16259 
          self.voucherAmount = iprot.readI64();
16260 
        else:
16261 
          iprot.skip(ftype)
16262 
      else:
16263 
        iprot.skip(ftype)
16264 
      iprot.readFieldEnd()
16265 
    iprot.readStructEnd()
16266 
 
16267 
  def write(self, oprot):
16268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16270 
      return
16271 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
16272 
    if self.catalog_item_id is not None:
16273 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16274 
      oprot.writeI64(self.catalog_item_id)
16275 
      oprot.writeFieldEnd()
16276 
    if self.voucherType is not None:
16277 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16278 
      oprot.writeI64(self.voucherType)
16279 
      oprot.writeFieldEnd()
16280 
    if self.voucherAmount is not None:
16281 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
16282 
      oprot.writeI64(self.voucherAmount)
16283 
      oprot.writeFieldEnd()
16284 
    oprot.writeFieldStop()
16285 
    oprot.writeStructEnd()
16286 
 
16287 
  def validate(self):
16288 
    return
16289 
 
16290 
 
16291 
  def __repr__(self):
16292 
    L = ['%s=%r' % (key, value)
16293 
      for key, value in self.__dict__.iteritems()]
16294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16295 
 
16296 
  def __eq__(self, other):
16297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16298 
 
16299 
  def __ne__(self, other):
16300 
    return not (self == other)
16301 
 
16302 
class addupdateVoucherForItem_result:
16303 
  """
16304 
  Attributes:
16305 
   - success
16306 
   - cex
16307 
  """
16308 
 
16309 
  thrift_spec = (
16310 
    (0, TType.BOOL, 'success', None, None, ), # 0
16311 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16312 
  )
16313 
 
16314 
  def __init__(self, success=None, cex=None,):
16315 
    self.success = success
16316 
    self.cex = cex
16317 
 
16318 
  def read(self, iprot):
16319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16321 
      return
16322 
    iprot.readStructBegin()
16323 
    while True:
16324 
      (fname, ftype, fid) = iprot.readFieldBegin()
16325 
      if ftype == TType.STOP:
16326 
        break
16327 
      if fid == 0:
16328 
        if ftype == TType.BOOL:
16329 
          self.success = iprot.readBool();
16330 
        else:
16331 
          iprot.skip(ftype)
16332 
      elif fid == 1:
16333 
        if ftype == TType.STRUCT:
16334 
          self.cex = CatalogServiceException()
16335 
          self.cex.read(iprot)
16336 
        else:
16337 
          iprot.skip(ftype)
16338 
      else:
16339 
        iprot.skip(ftype)
16340 
      iprot.readFieldEnd()
16341 
    iprot.readStructEnd()
16342 
 
16343 
  def write(self, oprot):
16344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16346 
      return
16347 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
16348 
    if self.success is not None:
16349 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16350 
      oprot.writeBool(self.success)
16351 
      oprot.writeFieldEnd()
16352 
    if self.cex is not None:
16353 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16354 
      self.cex.write(oprot)
16355 
      oprot.writeFieldEnd()
16356 
    oprot.writeFieldStop()
16357 
    oprot.writeStructEnd()
16358 
 
16359 
  def validate(self):
16360 
    return
16361 
 
16362 
 
16363 
  def __repr__(self):
16364 
    L = ['%s=%r' % (key, value)
16365 
      for key, value in self.__dict__.iteritems()]
16366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16367 
 
16368 
  def __eq__(self, other):
16369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16370 
 
16371 
  def __ne__(self, other):
16372 
    return not (self == other)
16373 
 
16374 
class deleteVoucherForItem_args:
16375 
  """
16376 
  Attributes:
16377 
   - catalog_item_id
16378 
   - voucherType
16379 
  """
16380 
 
16381 
  thrift_spec = (
16382 
    None, # 0
16383 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16384 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16385 
  )
16386 
 
16387 
  def __init__(self, catalog_item_id=None, voucherType=None,):
16388 
    self.catalog_item_id = catalog_item_id
16389 
    self.voucherType = voucherType
16390 
 
16391 
  def read(self, iprot):
16392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16394 
      return
16395 
    iprot.readStructBegin()
16396 
    while True:
16397 
      (fname, ftype, fid) = iprot.readFieldBegin()
16398 
      if ftype == TType.STOP:
16399 
        break
16400 
      if fid == 1:
16401 
        if ftype == TType.I64:
16402 
          self.catalog_item_id = iprot.readI64();
16403 
        else:
16404 
          iprot.skip(ftype)
16405 
      elif fid == 2:
16406 
        if ftype == TType.I64:
16407 
          self.voucherType = iprot.readI64();
16408 
        else:
16409 
          iprot.skip(ftype)
16410 
      else:
16411 
        iprot.skip(ftype)
16412 
      iprot.readFieldEnd()
16413 
    iprot.readStructEnd()
16414 
 
16415 
  def write(self, oprot):
16416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16418 
      return
16419 
    oprot.writeStructBegin('deleteVoucherForItem_args')
16420 
    if self.catalog_item_id is not None:
16421 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16422 
      oprot.writeI64(self.catalog_item_id)
16423 
      oprot.writeFieldEnd()
16424 
    if self.voucherType is not None:
16425 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16426 
      oprot.writeI64(self.voucherType)
16427 
      oprot.writeFieldEnd()
16428 
    oprot.writeFieldStop()
16429 
    oprot.writeStructEnd()
16430 
 
16431 
  def validate(self):
16432 
    return
16433 
 
16434 
 
16435 
  def __repr__(self):
16436 
    L = ['%s=%r' % (key, value)
16437 
      for key, value in self.__dict__.iteritems()]
16438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16439 
 
16440 
  def __eq__(self, other):
16441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16442 
 
16443 
  def __ne__(self, other):
16444 
    return not (self == other)
16445 
 
16446 
class deleteVoucherForItem_result:
16447 
  """
16448 
  Attributes:
16449 
   - success
16450 
   - cex
16451 
  """
16452 
 
16453 
  thrift_spec = (
16454 
    (0, TType.BOOL, 'success', None, None, ), # 0
16455 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16456 
  )
16457 
 
16458 
  def __init__(self, success=None, cex=None,):
16459 
    self.success = success
16460 
    self.cex = cex
16461 
 
16462 
  def read(self, iprot):
16463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16465 
      return
16466 
    iprot.readStructBegin()
16467 
    while True:
16468 
      (fname, ftype, fid) = iprot.readFieldBegin()
16469 
      if ftype == TType.STOP:
16470 
        break
16471 
      if fid == 0:
16472 
        if ftype == TType.BOOL:
16473 
          self.success = iprot.readBool();
16474 
        else:
16475 
          iprot.skip(ftype)
16476 
      elif fid == 1:
16477 
        if ftype == TType.STRUCT:
16478 
          self.cex = CatalogServiceException()
16479 
          self.cex.read(iprot)
16480 
        else:
16481 
          iprot.skip(ftype)
16482 
      else:
16483 
        iprot.skip(ftype)
16484 
      iprot.readFieldEnd()
16485 
    iprot.readStructEnd()
16486 
 
16487 
  def write(self, oprot):
16488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16490 
      return
16491 
    oprot.writeStructBegin('deleteVoucherForItem_result')
16492 
    if self.success is not None:
16493 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16494 
      oprot.writeBool(self.success)
16495 
      oprot.writeFieldEnd()
16496 
    if self.cex is not None:
16497 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16498 
      self.cex.write(oprot)
16499 
      oprot.writeFieldEnd()
16500 
    oprot.writeFieldStop()
16501 
    oprot.writeStructEnd()
16502 
 
16503 
  def validate(self):
16504 
    return
16505 
 
16506 
 
16507 
  def __repr__(self):
16508 
    L = ['%s=%r' % (key, value)
16509 
      for key, value in self.__dict__.iteritems()]
16510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16511 
 
16512 
  def __eq__(self, other):
16513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16514 
 
16515 
  def __ne__(self, other):
16516 
    return not (self == other)
16517 
 
16518 
class getVoucherAmount_args:
16519 
  """
16520 
  Attributes:
16521 
   - itemId
16522 
   - voucherType
16523 
  """
16524 
 
16525 
  thrift_spec = (
16526 
    None, # 0
16527 
    (1, TType.I64, 'itemId', None, None, ), # 1
16528 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16529 
  )
16530 
 
16531 
  def __init__(self, itemId=None, voucherType=None,):
16532 
    self.itemId = itemId
16533 
    self.voucherType = voucherType
16534 
 
16535 
  def read(self, iprot):
16536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16538 
      return
16539 
    iprot.readStructBegin()
16540 
    while True:
16541 
      (fname, ftype, fid) = iprot.readFieldBegin()
16542 
      if ftype == TType.STOP:
16543 
        break
16544 
      if fid == 1:
16545 
        if ftype == TType.I64:
16546 
          self.itemId = iprot.readI64();
16547 
        else:
16548 
          iprot.skip(ftype)
16549 
      elif fid == 2:
16550 
        if ftype == TType.I64:
16551 
          self.voucherType = iprot.readI64();
16552 
        else:
16553 
          iprot.skip(ftype)
16554 
      else:
16555 
        iprot.skip(ftype)
16556 
      iprot.readFieldEnd()
16557 
    iprot.readStructEnd()
16558 
 
16559 
  def write(self, oprot):
16560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16562 
      return
16563 
    oprot.writeStructBegin('getVoucherAmount_args')
16564 
    if self.itemId is not None:
16565 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16566 
      oprot.writeI64(self.itemId)
16567 
      oprot.writeFieldEnd()
16568 
    if self.voucherType is not None:
16569 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16570 
      oprot.writeI64(self.voucherType)
16571 
      oprot.writeFieldEnd()
16572 
    oprot.writeFieldStop()
16573 
    oprot.writeStructEnd()
16574 
 
16575 
  def validate(self):
16576 
    return
16577 
 
16578 
 
16579 
  def __repr__(self):
16580 
    L = ['%s=%r' % (key, value)
16581 
      for key, value in self.__dict__.iteritems()]
16582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16583 
 
16584 
  def __eq__(self, other):
16585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16586 
 
16587 
  def __ne__(self, other):
16588 
    return not (self == other)
16589 
 
16590 
class getVoucherAmount_result:
16591 
  """
16592 
  Attributes:
16593 
   - success
16594 
  """
16595 
 
16596 
  thrift_spec = (
16597 
    (0, TType.I64, 'success', None, None, ), # 0
16598 
  )
16599 
 
16600 
  def __init__(self, success=None,):
16601 
    self.success = success
16602 
 
16603 
  def read(self, iprot):
16604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16606 
      return
16607 
    iprot.readStructBegin()
16608 
    while True:
16609 
      (fname, ftype, fid) = iprot.readFieldBegin()
16610 
      if ftype == TType.STOP:
16611 
        break
16612 
      if fid == 0:
16613 
        if ftype == TType.I64:
16614 
          self.success = iprot.readI64();
16615 
        else:
16616 
          iprot.skip(ftype)
16617 
      else:
16618 
        iprot.skip(ftype)
16619 
      iprot.readFieldEnd()
16620 
    iprot.readStructEnd()
16621 
 
16622 
  def write(self, oprot):
16623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16625 
      return
16626 
    oprot.writeStructBegin('getVoucherAmount_result')
16627 
    if self.success is not None:
16628 
      oprot.writeFieldBegin('success', TType.I64, 0)
16629 
      oprot.writeI64(self.success)
16630 
      oprot.writeFieldEnd()
16631 
    oprot.writeFieldStop()
16632 
    oprot.writeStructEnd()
16633 
 
16634 
  def validate(self):
16635 
    return
16636 
 
16637 
 
16638 
  def __repr__(self):
16639 
    L = ['%s=%r' % (key, value)
16640 
      for key, value in self.__dict__.iteritems()]
16641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16642 
 
16643 
  def __eq__(self, other):
16644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16645 
 
16646 
  def __ne__(self, other):
16647 
    return not (self == other)
16648 
 
16649 
class getAllItemVouchers_args:
16650 
  """
16651 
  Attributes:
16652 
   - itemId
16653 
  """
16654 
 
16655 
  thrift_spec = (
16656 
    None, # 0
16657 
    (1, TType.I64, 'itemId', None, None, ), # 1
16658 
  )
16659 
 
16660 
  def __init__(self, itemId=None,):
16661 
    self.itemId = itemId
16662 
 
16663 
  def read(self, iprot):
16664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16666 
      return
16667 
    iprot.readStructBegin()
16668 
    while True:
16669 
      (fname, ftype, fid) = iprot.readFieldBegin()
16670 
      if ftype == TType.STOP:
16671 
        break
16672 
      if fid == 1:
16673 
        if ftype == TType.I64:
16674 
          self.itemId = iprot.readI64();
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      else:
16678 
        iprot.skip(ftype)
16679 
      iprot.readFieldEnd()
16680 
    iprot.readStructEnd()
16681 
 
16682 
  def write(self, oprot):
16683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16685 
      return
16686 
    oprot.writeStructBegin('getAllItemVouchers_args')
16687 
    if self.itemId is not None:
16688 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16689 
      oprot.writeI64(self.itemId)
16690 
      oprot.writeFieldEnd()
16691 
    oprot.writeFieldStop()
16692 
    oprot.writeStructEnd()
16693 
 
16694 
  def validate(self):
16695 
    return
16696 
 
16697 
 
16698 
  def __repr__(self):
16699 
    L = ['%s=%r' % (key, value)
16700 
      for key, value in self.__dict__.iteritems()]
16701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16702 
 
16703 
  def __eq__(self, other):
16704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16705 
 
16706 
  def __ne__(self, other):
16707 
    return not (self == other)
16708 
 
16709 
class getAllItemVouchers_result:
16710 
  """
16711 
  Attributes:
16712 
   - success
16713 
  """
16714 
 
16715 
  thrift_spec = (
16716 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
16717 
  )
16718 
 
16719 
  def __init__(self, success=None,):
16720 
    self.success = success
16721 
 
16722 
  def read(self, iprot):
16723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16725 
      return
16726 
    iprot.readStructBegin()
16727 
    while True:
16728 
      (fname, ftype, fid) = iprot.readFieldBegin()
16729 
      if ftype == TType.STOP:
16730 
        break
16731 
      if fid == 0:
16732 
        if ftype == TType.LIST:
16733 
          self.success = []
8590 kshitij.so 16734 
          (_etype347, _size344) = iprot.readListBegin()
16735 
          for _i348 in xrange(_size344):
16736 
            _elem349 = VoucherItemMapping()
16737 
            _elem349.read(iprot)
16738 
            self.success.append(_elem349)
5944 mandeep.dh 16739 
          iprot.readListEnd()
16740 
        else:
16741 
          iprot.skip(ftype)
16742 
      else:
16743 
        iprot.skip(ftype)
16744 
      iprot.readFieldEnd()
16745 
    iprot.readStructEnd()
16746 
 
16747 
  def write(self, oprot):
16748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16750 
      return
16751 
    oprot.writeStructBegin('getAllItemVouchers_result')
16752 
    if self.success is not None:
16753 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16754 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16755 
      for iter350 in self.success:
16756 
        iter350.write(oprot)
5944 mandeep.dh 16757 
      oprot.writeListEnd()
16758 
      oprot.writeFieldEnd()
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
16776 
 
16777 
class isValidCatalogItemId_args:
16778 
  """
16779 
  Attributes:
16780 
   - catalog_item_id
16781 
  """
16782 
 
16783 
  thrift_spec = (
16784 
    None, # 0
16785 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16786 
  )
16787 
 
16788 
  def __init__(self, catalog_item_id=None,):
16789 
    self.catalog_item_id = catalog_item_id
16790 
 
16791 
  def read(self, iprot):
16792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16794 
      return
16795 
    iprot.readStructBegin()
16796 
    while True:
16797 
      (fname, ftype, fid) = iprot.readFieldBegin()
16798 
      if ftype == TType.STOP:
16799 
        break
16800 
      if fid == 1:
16801 
        if ftype == TType.I64:
16802 
          self.catalog_item_id = iprot.readI64();
16803 
        else:
16804 
          iprot.skip(ftype)
16805 
      else:
16806 
        iprot.skip(ftype)
16807 
      iprot.readFieldEnd()
16808 
    iprot.readStructEnd()
16809 
 
16810 
  def write(self, oprot):
16811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16813 
      return
16814 
    oprot.writeStructBegin('isValidCatalogItemId_args')
16815 
    if self.catalog_item_id is not None:
16816 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16817 
      oprot.writeI64(self.catalog_item_id)
16818 
      oprot.writeFieldEnd()
16819 
    oprot.writeFieldStop()
16820 
    oprot.writeStructEnd()
16821 
 
16822 
  def validate(self):
16823 
    return
16824 
 
16825 
 
16826 
  def __repr__(self):
16827 
    L = ['%s=%r' % (key, value)
16828 
      for key, value in self.__dict__.iteritems()]
16829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16830 
 
16831 
  def __eq__(self, other):
16832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16833 
 
16834 
  def __ne__(self, other):
16835 
    return not (self == other)
16836 
 
16837 
class isValidCatalogItemId_result:
16838 
  """
16839 
  Attributes:
16840 
   - success
16841 
  """
16842 
 
16843 
  thrift_spec = (
16844 
    (0, TType.BOOL, 'success', None, None, ), # 0
16845 
  )
16846 
 
16847 
  def __init__(self, success=None,):
16848 
    self.success = success
16849 
 
16850 
  def read(self, iprot):
16851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16853 
      return
16854 
    iprot.readStructBegin()
16855 
    while True:
16856 
      (fname, ftype, fid) = iprot.readFieldBegin()
16857 
      if ftype == TType.STOP:
16858 
        break
16859 
      if fid == 0:
16860 
        if ftype == TType.BOOL:
16861 
          self.success = iprot.readBool();
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('isValidCatalogItemId_result')
16874 
    if self.success is not None:
16875 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16876 
      oprot.writeBool(self.success)
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)
6039 amit.gupta 16895 
 
16896 
class getVatPercentageForItem_args:
16897 
  """
16898 
  Attributes:
16899 
   - itemId
7330 amit.gupta 16900 
   - stateId
6039 amit.gupta 16901 
   - price
16902 
  """
16903 
 
16904 
  thrift_spec = (
16905 
    None, # 0
16906 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 16907 
    (2, TType.I64, 'stateId', None, None, ), # 2
16908 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 16909 
  )
16910 
 
7330 amit.gupta 16911 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 16912 
    self.itemId = itemId
7330 amit.gupta 16913 
    self.stateId = stateId
6039 amit.gupta 16914 
    self.price = price
16915 
 
16916 
  def read(self, iprot):
16917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16919 
      return
16920 
    iprot.readStructBegin()
16921 
    while True:
16922 
      (fname, ftype, fid) = iprot.readFieldBegin()
16923 
      if ftype == TType.STOP:
16924 
        break
16925 
      if fid == 1:
16926 
        if ftype == TType.I64:
16927 
          self.itemId = iprot.readI64();
16928 
        else:
16929 
          iprot.skip(ftype)
16930 
      elif fid == 2:
7330 amit.gupta 16931 
        if ftype == TType.I64:
16932 
          self.stateId = iprot.readI64();
16933 
        else:
16934 
          iprot.skip(ftype)
16935 
      elif fid == 3:
6039 amit.gupta 16936 
        if ftype == TType.DOUBLE:
16937 
          self.price = iprot.readDouble();
16938 
        else:
16939 
          iprot.skip(ftype)
16940 
      else:
16941 
        iprot.skip(ftype)
16942 
      iprot.readFieldEnd()
16943 
    iprot.readStructEnd()
16944 
 
16945 
  def write(self, oprot):
16946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16948 
      return
16949 
    oprot.writeStructBegin('getVatPercentageForItem_args')
16950 
    if self.itemId is not None:
16951 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16952 
      oprot.writeI64(self.itemId)
16953 
      oprot.writeFieldEnd()
7330 amit.gupta 16954 
    if self.stateId is not None:
16955 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
16956 
      oprot.writeI64(self.stateId)
16957 
      oprot.writeFieldEnd()
6039 amit.gupta 16958 
    if self.price is not None:
7330 amit.gupta 16959 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 16960 
      oprot.writeDouble(self.price)
16961 
      oprot.writeFieldEnd()
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 getVatPercentageForItem_result:
16981 
  """
16982 
  Attributes:
16983 
   - success
7340 amit.gupta 16984 
   - cex
6039 amit.gupta 16985 
  """
16986 
 
16987 
  thrift_spec = (
16988 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 16989 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 16990 
  )
16991 
 
7340 amit.gupta 16992 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 16993 
    self.success = success
7340 amit.gupta 16994 
    self.cex = cex
6039 amit.gupta 16995 
 
16996 
  def read(self, iprot):
16997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16999 
      return
17000 
    iprot.readStructBegin()
17001 
    while True:
17002 
      (fname, ftype, fid) = iprot.readFieldBegin()
17003 
      if ftype == TType.STOP:
17004 
        break
17005 
      if fid == 0:
17006 
        if ftype == TType.DOUBLE:
17007 
          self.success = iprot.readDouble();
17008 
        else:
17009 
          iprot.skip(ftype)
7340 amit.gupta 17010 
      elif fid == 1:
17011 
        if ftype == TType.STRUCT:
17012 
          self.cex = CatalogServiceException()
17013 
          self.cex.read(iprot)
17014 
        else:
17015 
          iprot.skip(ftype)
6039 amit.gupta 17016 
      else:
17017 
        iprot.skip(ftype)
17018 
      iprot.readFieldEnd()
17019 
    iprot.readStructEnd()
17020 
 
17021 
  def write(self, oprot):
17022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17024 
      return
17025 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17026 
    if self.success is not None:
17027 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17028 
      oprot.writeDouble(self.success)
17029 
      oprot.writeFieldEnd()
7340 amit.gupta 17030 
    if self.cex is not None:
17031 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17032 
      self.cex.write(oprot)
17033 
      oprot.writeFieldEnd()
6039 amit.gupta 17034 
    oprot.writeFieldStop()
17035 
    oprot.writeStructEnd()
17036 
 
17037 
  def validate(self):
17038 
    return
17039 
 
17040 
 
17041 
  def __repr__(self):
17042 
    L = ['%s=%r' % (key, value)
17043 
      for key, value in self.__dict__.iteritems()]
17044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17045 
 
17046 
  def __eq__(self, other):
17047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17048 
 
17049 
  def __ne__(self, other):
17050 
    return not (self == other)
17051 
 
17052 
class getVatAmountForItem_args:
17053 
  """
17054 
  Attributes:
17055 
   - itemId
17056 
   - price
17057 
  """
17058 
 
17059 
  thrift_spec = (
17060 
    None, # 0
17061 
    (1, TType.I64, 'itemId', None, None, ), # 1
17062 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17063 
  )
17064 
 
17065 
  def __init__(self, itemId=None, price=None,):
17066 
    self.itemId = itemId
17067 
    self.price = price
17068 
 
17069 
  def read(self, iprot):
17070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17072 
      return
17073 
    iprot.readStructBegin()
17074 
    while True:
17075 
      (fname, ftype, fid) = iprot.readFieldBegin()
17076 
      if ftype == TType.STOP:
17077 
        break
17078 
      if fid == 1:
17079 
        if ftype == TType.I64:
17080 
          self.itemId = iprot.readI64();
17081 
        else:
17082 
          iprot.skip(ftype)
17083 
      elif fid == 2:
17084 
        if ftype == TType.DOUBLE:
17085 
          self.price = iprot.readDouble();
17086 
        else:
17087 
          iprot.skip(ftype)
17088 
      else:
17089 
        iprot.skip(ftype)
17090 
      iprot.readFieldEnd()
17091 
    iprot.readStructEnd()
17092 
 
17093 
  def write(self, oprot):
17094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17096 
      return
17097 
    oprot.writeStructBegin('getVatAmountForItem_args')
17098 
    if self.itemId is not None:
17099 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17100 
      oprot.writeI64(self.itemId)
17101 
      oprot.writeFieldEnd()
17102 
    if self.price is not None:
17103 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17104 
      oprot.writeDouble(self.price)
17105 
      oprot.writeFieldEnd()
17106 
    oprot.writeFieldStop()
17107 
    oprot.writeStructEnd()
17108 
 
17109 
  def validate(self):
17110 
    return
17111 
 
17112 
 
17113 
  def __repr__(self):
17114 
    L = ['%s=%r' % (key, value)
17115 
      for key, value in self.__dict__.iteritems()]
17116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17117 
 
17118 
  def __eq__(self, other):
17119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17120 
 
17121 
  def __ne__(self, other):
17122 
    return not (self == other)
17123 
 
17124 
class getVatAmountForItem_result:
17125 
  """
17126 
  Attributes:
17127 
   - success
17128 
  """
17129 
 
17130 
  thrift_spec = (
17131 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17132 
  )
17133 
 
17134 
  def __init__(self, success=None,):
17135 
    self.success = success
17136 
 
17137 
  def read(self, iprot):
17138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17140 
      return
17141 
    iprot.readStructBegin()
17142 
    while True:
17143 
      (fname, ftype, fid) = iprot.readFieldBegin()
17144 
      if ftype == TType.STOP:
17145 
        break
17146 
      if fid == 0:
17147 
        if ftype == TType.DOUBLE:
17148 
          self.success = iprot.readDouble();
17149 
        else:
17150 
          iprot.skip(ftype)
17151 
      else:
17152 
        iprot.skip(ftype)
17153 
      iprot.readFieldEnd()
17154 
    iprot.readStructEnd()
17155 
 
17156 
  def write(self, oprot):
17157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17159 
      return
17160 
    oprot.writeStructBegin('getVatAmountForItem_result')
17161 
    if self.success is not None:
17162 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17163 
      oprot.writeDouble(self.success)
17164 
      oprot.writeFieldEnd()
17165 
    oprot.writeFieldStop()
17166 
    oprot.writeStructEnd()
17167 
 
17168 
  def validate(self):
17169 
    return
17170 
 
17171 
 
17172 
  def __repr__(self):
17173 
    L = ['%s=%r' % (key, value)
17174 
      for key, value in self.__dict__.iteritems()]
17175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17176 
 
17177 
  def __eq__(self, other):
17178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17179 
 
17180 
  def __ne__(self, other):
17181 
    return not (self == other)
6531 vikram.rag 17182 
 
17183 
class getAllIgnoredInventoryUpdateItemsList_args:
17184 
  """
17185 
  Attributes:
17186 
   - offset
17187 
   - limit
17188 
  """
17189 
 
17190 
  thrift_spec = (
17191 
    None, # 0
17192 
    (1, TType.I32, 'offset', None, None, ), # 1
17193 
    (2, TType.I32, 'limit', None, None, ), # 2
17194 
  )
17195 
 
17196 
  def __init__(self, offset=None, limit=None,):
17197 
    self.offset = offset
17198 
    self.limit = limit
17199 
 
17200 
  def read(self, iprot):
17201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17203 
      return
17204 
    iprot.readStructBegin()
17205 
    while True:
17206 
      (fname, ftype, fid) = iprot.readFieldBegin()
17207 
      if ftype == TType.STOP:
17208 
        break
17209 
      if fid == 1:
17210 
        if ftype == TType.I32:
17211 
          self.offset = iprot.readI32();
17212 
        else:
17213 
          iprot.skip(ftype)
17214 
      elif fid == 2:
17215 
        if ftype == TType.I32:
17216 
          self.limit = iprot.readI32();
17217 
        else:
17218 
          iprot.skip(ftype)
17219 
      else:
17220 
        iprot.skip(ftype)
17221 
      iprot.readFieldEnd()
17222 
    iprot.readStructEnd()
17223 
 
17224 
  def write(self, oprot):
17225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17227 
      return
17228 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17229 
    if self.offset is not None:
17230 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17231 
      oprot.writeI32(self.offset)
17232 
      oprot.writeFieldEnd()
17233 
    if self.limit is not None:
17234 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17235 
      oprot.writeI32(self.limit)
17236 
      oprot.writeFieldEnd()
17237 
    oprot.writeFieldStop()
17238 
    oprot.writeStructEnd()
17239 
 
17240 
  def validate(self):
17241 
    return
17242 
 
17243 
 
17244 
  def __repr__(self):
17245 
    L = ['%s=%r' % (key, value)
17246 
      for key, value in self.__dict__.iteritems()]
17247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17248 
 
17249 
  def __eq__(self, other):
17250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17251 
 
17252 
  def __ne__(self, other):
17253 
    return not (self == other)
17254 
 
17255 
class getAllIgnoredInventoryUpdateItemsList_result:
17256 
  """
17257 
  Attributes:
17258 
   - success
17259 
  """
17260 
 
17261 
  thrift_spec = (
17262 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17263 
  )
17264 
 
17265 
  def __init__(self, success=None,):
17266 
    self.success = success
17267 
 
17268 
  def read(self, iprot):
17269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17271 
      return
17272 
    iprot.readStructBegin()
17273 
    while True:
17274 
      (fname, ftype, fid) = iprot.readFieldBegin()
17275 
      if ftype == TType.STOP:
17276 
        break
17277 
      if fid == 0:
17278 
        if ftype == TType.LIST:
17279 
          self.success = []
8590 kshitij.so 17280 
          (_etype354, _size351) = iprot.readListBegin()
17281 
          for _i355 in xrange(_size351):
17282 
            _elem356 = Item()
17283 
            _elem356.read(iprot)
17284 
            self.success.append(_elem356)
6531 vikram.rag 17285 
          iprot.readListEnd()
17286 
        else:
17287 
          iprot.skip(ftype)
17288 
      else:
17289 
        iprot.skip(ftype)
17290 
      iprot.readFieldEnd()
17291 
    iprot.readStructEnd()
17292 
 
17293 
  def write(self, oprot):
17294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17296 
      return
17297 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
17298 
    if self.success is not None:
17299 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17300 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17301 
      for iter357 in self.success:
17302 
        iter357.write(oprot)
6531 vikram.rag 17303 
      oprot.writeListEnd()
17304 
      oprot.writeFieldEnd()
17305 
    oprot.writeFieldStop()
17306 
    oprot.writeStructEnd()
17307 
 
17308 
  def validate(self):
17309 
    return
17310 
 
17311 
 
17312 
  def __repr__(self):
17313 
    L = ['%s=%r' % (key, value)
17314 
      for key, value in self.__dict__.iteritems()]
17315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17316 
 
17317 
  def __eq__(self, other):
17318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17319 
 
17320 
  def __ne__(self, other):
17321 
    return not (self == other)
6805 anupam.sin 17322 
 
6821 amar.kumar 17323 
class getAllAliveItems_args:
17324 
 
17325 
  thrift_spec = (
17326 
  )
17327 
 
17328 
  def read(self, iprot):
17329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17331 
      return
17332 
    iprot.readStructBegin()
17333 
    while True:
17334 
      (fname, ftype, fid) = iprot.readFieldBegin()
17335 
      if ftype == TType.STOP:
17336 
        break
17337 
      else:
17338 
        iprot.skip(ftype)
17339 
      iprot.readFieldEnd()
17340 
    iprot.readStructEnd()
17341 
 
17342 
  def write(self, oprot):
17343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17345 
      return
17346 
    oprot.writeStructBegin('getAllAliveItems_args')
17347 
    oprot.writeFieldStop()
17348 
    oprot.writeStructEnd()
17349 
 
17350 
  def validate(self):
17351 
    return
17352 
 
17353 
 
17354 
  def __repr__(self):
17355 
    L = ['%s=%r' % (key, value)
17356 
      for key, value in self.__dict__.iteritems()]
17357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17358 
 
17359 
  def __eq__(self, other):
17360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17361 
 
17362 
  def __ne__(self, other):
17363 
    return not (self == other)
17364 
 
17365 
class getAllAliveItems_result:
17366 
  """
17367 
  Attributes:
17368 
   - success
17369 
  """
17370 
 
17371 
  thrift_spec = (
17372 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17373 
  )
17374 
 
17375 
  def __init__(self, success=None,):
17376 
    self.success = success
17377 
 
17378 
  def read(self, iprot):
17379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17381 
      return
17382 
    iprot.readStructBegin()
17383 
    while True:
17384 
      (fname, ftype, fid) = iprot.readFieldBegin()
17385 
      if ftype == TType.STOP:
17386 
        break
17387 
      if fid == 0:
17388 
        if ftype == TType.LIST:
17389 
          self.success = []
8590 kshitij.so 17390 
          (_etype361, _size358) = iprot.readListBegin()
17391 
          for _i362 in xrange(_size358):
17392 
            _elem363 = Item()
17393 
            _elem363.read(iprot)
17394 
            self.success.append(_elem363)
6821 amar.kumar 17395 
          iprot.readListEnd()
17396 
        else:
17397 
          iprot.skip(ftype)
17398 
      else:
17399 
        iprot.skip(ftype)
17400 
      iprot.readFieldEnd()
17401 
    iprot.readStructEnd()
17402 
 
17403 
  def write(self, oprot):
17404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17406 
      return
17407 
    oprot.writeStructBegin('getAllAliveItems_result')
17408 
    if self.success is not None:
17409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17411 
      for iter364 in self.success:
17412 
        iter364.write(oprot)
6821 amar.kumar 17413 
      oprot.writeListEnd()
17414 
      oprot.writeFieldEnd()
17415 
    oprot.writeFieldStop()
17416 
    oprot.writeStructEnd()
17417 
 
17418 
  def validate(self):
17419 
    return
17420 
 
17421 
 
17422 
  def __repr__(self):
17423 
    L = ['%s=%r' % (key, value)
17424 
      for key, value in self.__dict__.iteritems()]
17425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17426 
 
17427 
  def __eq__(self, other):
17428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17429 
 
17430 
  def __ne__(self, other):
17431 
    return not (self == other)
17432 
 
6805 anupam.sin 17433 
class getInsuranceAmount_args:
17434 
  """
17435 
  Attributes:
17436 
   - itemId
6921 anupam.sin 17437 
   - price
6805 anupam.sin 17438 
   - insurerId
17439 
   - quantity
17440 
  """
17441 
 
17442 
  thrift_spec = (
17443 
    None, # 0
17444 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 17445 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17446 
    (3, TType.I64, 'insurerId', None, None, ), # 3
17447 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 17448 
  )
17449 
 
6921 anupam.sin 17450 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 17451 
    self.itemId = itemId
6921 anupam.sin 17452 
    self.price = price
6805 anupam.sin 17453 
    self.insurerId = insurerId
17454 
    self.quantity = quantity
17455 
 
17456 
  def read(self, iprot):
17457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17459 
      return
17460 
    iprot.readStructBegin()
17461 
    while True:
17462 
      (fname, ftype, fid) = iprot.readFieldBegin()
17463 
      if ftype == TType.STOP:
17464 
        break
17465 
      if fid == 1:
17466 
        if ftype == TType.I64:
17467 
          self.itemId = iprot.readI64();
17468 
        else:
17469 
          iprot.skip(ftype)
17470 
      elif fid == 2:
6921 anupam.sin 17471 
        if ftype == TType.DOUBLE:
17472 
          self.price = iprot.readDouble();
17473 
        else:
17474 
          iprot.skip(ftype)
17475 
      elif fid == 3:
6805 anupam.sin 17476 
        if ftype == TType.I64:
17477 
          self.insurerId = iprot.readI64();
17478 
        else:
17479 
          iprot.skip(ftype)
6921 anupam.sin 17480 
      elif fid == 4:
6805 anupam.sin 17481 
        if ftype == TType.I64:
17482 
          self.quantity = iprot.readI64();
17483 
        else:
17484 
          iprot.skip(ftype)
17485 
      else:
17486 
        iprot.skip(ftype)
17487 
      iprot.readFieldEnd()
17488 
    iprot.readStructEnd()
17489 
 
17490 
  def write(self, oprot):
17491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17493 
      return
17494 
    oprot.writeStructBegin('getInsuranceAmount_args')
17495 
    if self.itemId is not None:
17496 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17497 
      oprot.writeI64(self.itemId)
17498 
      oprot.writeFieldEnd()
6921 anupam.sin 17499 
    if self.price is not None:
17500 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17501 
      oprot.writeDouble(self.price)
17502 
      oprot.writeFieldEnd()
6805 anupam.sin 17503 
    if self.insurerId is not None:
6921 anupam.sin 17504 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 17505 
      oprot.writeI64(self.insurerId)
17506 
      oprot.writeFieldEnd()
17507 
    if self.quantity is not None:
6921 anupam.sin 17508 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 17509 
      oprot.writeI64(self.quantity)
17510 
      oprot.writeFieldEnd()
17511 
    oprot.writeFieldStop()
17512 
    oprot.writeStructEnd()
17513 
 
17514 
  def validate(self):
17515 
    return
17516 
 
17517 
 
17518 
  def __repr__(self):
17519 
    L = ['%s=%r' % (key, value)
17520 
      for key, value in self.__dict__.iteritems()]
17521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17522 
 
17523 
  def __eq__(self, other):
17524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17525 
 
17526 
  def __ne__(self, other):
17527 
    return not (self == other)
17528 
 
17529 
class getInsuranceAmount_result:
17530 
  """
17531 
  Attributes:
17532 
   - success
17533 
  """
17534 
 
17535 
  thrift_spec = (
17536 
    (0, TType.I64, 'success', None, None, ), # 0
17537 
  )
17538 
 
17539 
  def __init__(self, success=None,):
17540 
    self.success = success
17541 
 
17542 
  def read(self, iprot):
17543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17545 
      return
17546 
    iprot.readStructBegin()
17547 
    while True:
17548 
      (fname, ftype, fid) = iprot.readFieldBegin()
17549 
      if ftype == TType.STOP:
17550 
        break
17551 
      if fid == 0:
17552 
        if ftype == TType.I64:
17553 
          self.success = iprot.readI64();
17554 
        else:
17555 
          iprot.skip(ftype)
17556 
      else:
17557 
        iprot.skip(ftype)
17558 
      iprot.readFieldEnd()
17559 
    iprot.readStructEnd()
17560 
 
17561 
  def write(self, oprot):
17562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17564 
      return
17565 
    oprot.writeStructBegin('getInsuranceAmount_result')
17566 
    if self.success is not None:
17567 
      oprot.writeFieldBegin('success', TType.I64, 0)
17568 
      oprot.writeI64(self.success)
17569 
      oprot.writeFieldEnd()
17570 
    oprot.writeFieldStop()
17571 
    oprot.writeStructEnd()
17572 
 
17573 
  def validate(self):
17574 
    return
17575 
 
17576 
 
17577 
  def __repr__(self):
17578 
    L = ['%s=%r' % (key, value)
17579 
      for key, value in self.__dict__.iteritems()]
17580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17581 
 
17582 
  def __eq__(self, other):
17583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17584 
 
17585 
  def __ne__(self, other):
17586 
    return not (self == other)
17587 
 
17588 
class getInsurer_args:
17589 
  """
17590 
  Attributes:
17591 
   - insurerId
17592 
  """
17593 
 
17594 
  thrift_spec = (
17595 
    None, # 0
17596 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17597 
  )
17598 
 
17599 
  def __init__(self, insurerId=None,):
17600 
    self.insurerId = insurerId
17601 
 
17602 
  def read(self, iprot):
17603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17605 
      return
17606 
    iprot.readStructBegin()
17607 
    while True:
17608 
      (fname, ftype, fid) = iprot.readFieldBegin()
17609 
      if ftype == TType.STOP:
17610 
        break
17611 
      if fid == 1:
17612 
        if ftype == TType.I64:
17613 
          self.insurerId = iprot.readI64();
17614 
        else:
17615 
          iprot.skip(ftype)
17616 
      else:
17617 
        iprot.skip(ftype)
17618 
      iprot.readFieldEnd()
17619 
    iprot.readStructEnd()
17620 
 
17621 
  def write(self, oprot):
17622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17624 
      return
17625 
    oprot.writeStructBegin('getInsurer_args')
17626 
    if self.insurerId is not None:
17627 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17628 
      oprot.writeI64(self.insurerId)
17629 
      oprot.writeFieldEnd()
17630 
    oprot.writeFieldStop()
17631 
    oprot.writeStructEnd()
17632 
 
17633 
  def validate(self):
17634 
    return
17635 
 
17636 
 
17637 
  def __repr__(self):
17638 
    L = ['%s=%r' % (key, value)
17639 
      for key, value in self.__dict__.iteritems()]
17640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17641 
 
17642 
  def __eq__(self, other):
17643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17644 
 
17645 
  def __ne__(self, other):
17646 
    return not (self == other)
17647 
 
17648 
class getInsurer_result:
17649 
  """
17650 
  Attributes:
17651 
   - success
17652 
  """
17653 
 
17654 
  thrift_spec = (
17655 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
17656 
  )
17657 
 
17658 
  def __init__(self, success=None,):
17659 
    self.success = success
17660 
 
17661 
  def read(self, iprot):
17662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17664 
      return
17665 
    iprot.readStructBegin()
17666 
    while True:
17667 
      (fname, ftype, fid) = iprot.readFieldBegin()
17668 
      if ftype == TType.STOP:
17669 
        break
17670 
      if fid == 0:
17671 
        if ftype == TType.STRUCT:
17672 
          self.success = Insurer()
17673 
          self.success.read(iprot)
17674 
        else:
17675 
          iprot.skip(ftype)
17676 
      else:
17677 
        iprot.skip(ftype)
17678 
      iprot.readFieldEnd()
17679 
    iprot.readStructEnd()
17680 
 
17681 
  def write(self, oprot):
17682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17684 
      return
17685 
    oprot.writeStructBegin('getInsurer_result')
17686 
    if self.success is not None:
17687 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17688 
      self.success.write(oprot)
17689 
      oprot.writeFieldEnd()
17690 
    oprot.writeFieldStop()
17691 
    oprot.writeStructEnd()
17692 
 
17693 
  def validate(self):
17694 
    return
17695 
 
17696 
 
17697 
  def __repr__(self):
17698 
    L = ['%s=%r' % (key, value)
17699 
      for key, value in self.__dict__.iteritems()]
17700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17701 
 
17702 
  def __eq__(self, other):
17703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17704 
 
17705 
  def __ne__(self, other):
17706 
    return not (self == other)
6838 vikram.rag 17707 
 
17708 
class getAllInsurers_args:
17709 
 
17710 
  thrift_spec = (
17711 
  )
17712 
 
17713 
  def read(self, iprot):
17714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17716 
      return
17717 
    iprot.readStructBegin()
17718 
    while True:
17719 
      (fname, ftype, fid) = iprot.readFieldBegin()
17720 
      if ftype == TType.STOP:
17721 
        break
17722 
      else:
17723 
        iprot.skip(ftype)
17724 
      iprot.readFieldEnd()
17725 
    iprot.readStructEnd()
17726 
 
17727 
  def write(self, oprot):
17728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17730 
      return
17731 
    oprot.writeStructBegin('getAllInsurers_args')
17732 
    oprot.writeFieldStop()
17733 
    oprot.writeStructEnd()
17734 
 
17735 
  def validate(self):
17736 
    return
17737 
 
17738 
 
17739 
  def __repr__(self):
17740 
    L = ['%s=%r' % (key, value)
17741 
      for key, value in self.__dict__.iteritems()]
17742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17743 
 
17744 
  def __eq__(self, other):
17745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17746 
 
17747 
  def __ne__(self, other):
17748 
    return not (self == other)
17749 
 
17750 
class getAllInsurers_result:
17751 
  """
17752 
  Attributes:
17753 
   - success
17754 
  """
17755 
 
17756 
  thrift_spec = (
17757 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
17758 
  )
17759 
 
17760 
  def __init__(self, success=None,):
17761 
    self.success = success
17762 
 
17763 
  def read(self, iprot):
17764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17766 
      return
17767 
    iprot.readStructBegin()
17768 
    while True:
17769 
      (fname, ftype, fid) = iprot.readFieldBegin()
17770 
      if ftype == TType.STOP:
17771 
        break
17772 
      if fid == 0:
17773 
        if ftype == TType.LIST:
17774 
          self.success = []
8590 kshitij.so 17775 
          (_etype368, _size365) = iprot.readListBegin()
17776 
          for _i369 in xrange(_size365):
17777 
            _elem370 = Insurer()
17778 
            _elem370.read(iprot)
17779 
            self.success.append(_elem370)
6838 vikram.rag 17780 
          iprot.readListEnd()
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('getAllInsurers_result')
17793 
    if self.success is not None:
17794 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17795 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17796 
      for iter371 in self.success:
17797 
        iter371.write(oprot)
6838 vikram.rag 17798 
      oprot.writeListEnd()
17799 
      oprot.writeFieldEnd()
17800 
    oprot.writeFieldStop()
17801 
    oprot.writeStructEnd()
17802 
 
17803 
  def validate(self):
17804 
    return
17805 
 
17806 
 
17807 
  def __repr__(self):
17808 
    L = ['%s=%r' % (key, value)
17809 
      for key, value in self.__dict__.iteritems()]
17810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17811 
 
17812 
  def __eq__(self, other):
17813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17814 
 
17815 
  def __ne__(self, other):
17816 
    return not (self == other)
6962 rajveer 17817 
 
17818 
class updateInsuranceDeclaredAmount_args:
17819 
  """
17820 
  Attributes:
17821 
   - insurerId
17822 
   - amount
17823 
  """
17824 
 
17825 
  thrift_spec = (
17826 
    None, # 0
17827 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17828 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
17829 
  )
17830 
 
17831 
  def __init__(self, insurerId=None, amount=None,):
17832 
    self.insurerId = insurerId
17833 
    self.amount = amount
17834 
 
17835 
  def read(self, iprot):
17836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17838 
      return
17839 
    iprot.readStructBegin()
17840 
    while True:
17841 
      (fname, ftype, fid) = iprot.readFieldBegin()
17842 
      if ftype == TType.STOP:
17843 
        break
17844 
      if fid == 1:
17845 
        if ftype == TType.I64:
17846 
          self.insurerId = iprot.readI64();
17847 
        else:
17848 
          iprot.skip(ftype)
17849 
      elif fid == 2:
17850 
        if ftype == TType.DOUBLE:
17851 
          self.amount = iprot.readDouble();
17852 
        else:
17853 
          iprot.skip(ftype)
17854 
      else:
17855 
        iprot.skip(ftype)
17856 
      iprot.readFieldEnd()
17857 
    iprot.readStructEnd()
17858 
 
17859 
  def write(self, oprot):
17860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17862 
      return
17863 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
17864 
    if self.insurerId is not None:
17865 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17866 
      oprot.writeI64(self.insurerId)
17867 
      oprot.writeFieldEnd()
17868 
    if self.amount is not None:
17869 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
17870 
      oprot.writeDouble(self.amount)
17871 
      oprot.writeFieldEnd()
17872 
    oprot.writeFieldStop()
17873 
    oprot.writeStructEnd()
17874 
 
17875 
  def validate(self):
17876 
    return
17877 
 
17878 
 
17879 
  def __repr__(self):
17880 
    L = ['%s=%r' % (key, value)
17881 
      for key, value in self.__dict__.iteritems()]
17882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17883 
 
17884 
  def __eq__(self, other):
17885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17886 
 
17887 
  def __ne__(self, other):
17888 
    return not (self == other)
17889 
 
17890 
class updateInsuranceDeclaredAmount_result:
17891 
 
17892 
  thrift_spec = (
17893 
  )
17894 
 
17895 
  def read(self, iprot):
17896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17898 
      return
17899 
    iprot.readStructBegin()
17900 
    while True:
17901 
      (fname, ftype, fid) = iprot.readFieldBegin()
17902 
      if ftype == TType.STOP:
17903 
        break
17904 
      else:
17905 
        iprot.skip(ftype)
17906 
      iprot.readFieldEnd()
17907 
    iprot.readStructEnd()
17908 
 
17909 
  def write(self, oprot):
17910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17912 
      return
17913 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
17914 
    oprot.writeFieldStop()
17915 
    oprot.writeStructEnd()
17916 
 
17917 
  def validate(self):
17918 
    return
17919 
 
17920 
 
17921 
  def __repr__(self):
17922 
    L = ['%s=%r' % (key, value)
17923 
      for key, value in self.__dict__.iteritems()]
17924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17925 
 
17926 
  def __eq__(self, other):
17927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17928 
 
17929 
  def __ne__(self, other):
17930 
    return not (self == other)
7190 amar.kumar 17931 
 
17932 
class getFreebieForItem_args:
17933 
  """
17934 
  Attributes:
17935 
   - itemId
17936 
  """
17937 
 
17938 
  thrift_spec = (
17939 
    None, # 0
17940 
    (1, TType.I64, 'itemId', None, None, ), # 1
17941 
  )
17942 
 
17943 
  def __init__(self, itemId=None,):
17944 
    self.itemId = itemId
17945 
 
17946 
  def read(self, iprot):
17947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17949 
      return
17950 
    iprot.readStructBegin()
17951 
    while True:
17952 
      (fname, ftype, fid) = iprot.readFieldBegin()
17953 
      if ftype == TType.STOP:
17954 
        break
17955 
      if fid == 1:
17956 
        if ftype == TType.I64:
17957 
          self.itemId = iprot.readI64();
17958 
        else:
17959 
          iprot.skip(ftype)
17960 
      else:
17961 
        iprot.skip(ftype)
17962 
      iprot.readFieldEnd()
17963 
    iprot.readStructEnd()
17964 
 
17965 
  def write(self, oprot):
17966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17968 
      return
17969 
    oprot.writeStructBegin('getFreebieForItem_args')
17970 
    if self.itemId is not None:
17971 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17972 
      oprot.writeI64(self.itemId)
17973 
      oprot.writeFieldEnd()
17974 
    oprot.writeFieldStop()
17975 
    oprot.writeStructEnd()
17976 
 
17977 
  def validate(self):
17978 
    return
17979 
 
17980 
 
17981 
  def __repr__(self):
17982 
    L = ['%s=%r' % (key, value)
17983 
      for key, value in self.__dict__.iteritems()]
17984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17985 
 
17986 
  def __eq__(self, other):
17987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17988 
 
17989 
  def __ne__(self, other):
17990 
    return not (self == other)
17991 
 
17992 
class getFreebieForItem_result:
17993 
  """
17994 
  Attributes:
17995 
   - success
17996 
  """
17997 
 
17998 
  thrift_spec = (
17999 
    (0, TType.I64, 'success', None, None, ), # 0
18000 
  )
18001 
 
18002 
  def __init__(self, success=None,):
18003 
    self.success = success
18004 
 
18005 
  def read(self, iprot):
18006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18008 
      return
18009 
    iprot.readStructBegin()
18010 
    while True:
18011 
      (fname, ftype, fid) = iprot.readFieldBegin()
18012 
      if ftype == TType.STOP:
18013 
        break
18014 
      if fid == 0:
18015 
        if ftype == TType.I64:
18016 
          self.success = iprot.readI64();
18017 
        else:
18018 
          iprot.skip(ftype)
18019 
      else:
18020 
        iprot.skip(ftype)
18021 
      iprot.readFieldEnd()
18022 
    iprot.readStructEnd()
18023 
 
18024 
  def write(self, oprot):
18025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18027 
      return
18028 
    oprot.writeStructBegin('getFreebieForItem_result')
18029 
    if self.success is not None:
18030 
      oprot.writeFieldBegin('success', TType.I64, 0)
18031 
      oprot.writeI64(self.success)
18032 
      oprot.writeFieldEnd()
18033 
    oprot.writeFieldStop()
18034 
    oprot.writeStructEnd()
18035 
 
18036 
  def validate(self):
18037 
    return
18038 
 
18039 
 
18040 
  def __repr__(self):
18041 
    L = ['%s=%r' % (key, value)
18042 
      for key, value in self.__dict__.iteritems()]
18043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18044 
 
18045 
  def __eq__(self, other):
18046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18047 
 
18048 
  def __ne__(self, other):
18049 
    return not (self == other)
18050 
 
18051 
class addOrUpdateFreebieForItem_args:
18052 
  """
18053 
  Attributes:
18054 
   - freebieItem
18055 
  """
18056 
 
18057 
  thrift_spec = (
18058 
    None, # 0
18059 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18060 
  )
18061 
 
18062 
  def __init__(self, freebieItem=None,):
18063 
    self.freebieItem = freebieItem
18064 
 
18065 
  def read(self, iprot):
18066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18068 
      return
18069 
    iprot.readStructBegin()
18070 
    while True:
18071 
      (fname, ftype, fid) = iprot.readFieldBegin()
18072 
      if ftype == TType.STOP:
18073 
        break
18074 
      if fid == 1:
18075 
        if ftype == TType.STRUCT:
18076 
          self.freebieItem = FreebieItem()
18077 
          self.freebieItem.read(iprot)
18078 
        else:
18079 
          iprot.skip(ftype)
18080 
      else:
18081 
        iprot.skip(ftype)
18082 
      iprot.readFieldEnd()
18083 
    iprot.readStructEnd()
18084 
 
18085 
  def write(self, oprot):
18086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18088 
      return
18089 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18090 
    if self.freebieItem is not None:
18091 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18092 
      self.freebieItem.write(oprot)
18093 
      oprot.writeFieldEnd()
18094 
    oprot.writeFieldStop()
18095 
    oprot.writeStructEnd()
18096 
 
18097 
  def validate(self):
18098 
    return
18099 
 
18100 
 
18101 
  def __repr__(self):
18102 
    L = ['%s=%r' % (key, value)
18103 
      for key, value in self.__dict__.iteritems()]
18104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18105 
 
18106 
  def __eq__(self, other):
18107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18108 
 
18109 
  def __ne__(self, other):
18110 
    return not (self == other)
18111 
 
18112 
class addOrUpdateFreebieForItem_result:
18113 
 
18114 
  thrift_spec = (
18115 
  )
18116 
 
18117 
  def read(self, iprot):
18118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18120 
      return
18121 
    iprot.readStructBegin()
18122 
    while True:
18123 
      (fname, ftype, fid) = iprot.readFieldBegin()
18124 
      if ftype == TType.STOP:
18125 
        break
18126 
      else:
18127 
        iprot.skip(ftype)
18128 
      iprot.readFieldEnd()
18129 
    iprot.readStructEnd()
18130 
 
18131 
  def write(self, oprot):
18132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18134 
      return
18135 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18136 
    oprot.writeFieldStop()
18137 
    oprot.writeStructEnd()
18138 
 
18139 
  def validate(self):
18140 
    return
18141 
 
18142 
 
18143 
  def __repr__(self):
18144 
    L = ['%s=%r' % (key, value)
18145 
      for key, value in self.__dict__.iteritems()]
18146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18147 
 
18148 
  def __eq__(self, other):
18149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18150 
 
18151 
  def __ne__(self, other):
18152 
    return not (self == other)
7256 rajveer 18153 
 
7272 amit.gupta 18154 
class addOrUpdateBrandInfo_args:
18155 
  """
18156 
  Attributes:
18157 
   - brandInfo
18158 
  """
18159 
 
18160 
  thrift_spec = (
18161 
    None, # 0
18162 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18163 
  )
18164 
 
18165 
  def __init__(self, brandInfo=None,):
18166 
    self.brandInfo = brandInfo
18167 
 
18168 
  def read(self, iprot):
18169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18171 
      return
18172 
    iprot.readStructBegin()
18173 
    while True:
18174 
      (fname, ftype, fid) = iprot.readFieldBegin()
18175 
      if ftype == TType.STOP:
18176 
        break
18177 
      if fid == 1:
18178 
        if ftype == TType.STRUCT:
18179 
          self.brandInfo = BrandInfo()
18180 
          self.brandInfo.read(iprot)
18181 
        else:
18182 
          iprot.skip(ftype)
18183 
      else:
18184 
        iprot.skip(ftype)
18185 
      iprot.readFieldEnd()
18186 
    iprot.readStructEnd()
18187 
 
18188 
  def write(self, oprot):
18189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18191 
      return
18192 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18193 
    if self.brandInfo is not None:
18194 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18195 
      self.brandInfo.write(oprot)
18196 
      oprot.writeFieldEnd()
18197 
    oprot.writeFieldStop()
18198 
    oprot.writeStructEnd()
18199 
 
18200 
  def validate(self):
18201 
    return
18202 
 
18203 
 
18204 
  def __repr__(self):
18205 
    L = ['%s=%r' % (key, value)
18206 
      for key, value in self.__dict__.iteritems()]
18207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18208 
 
18209 
  def __eq__(self, other):
18210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18211 
 
18212 
  def __ne__(self, other):
18213 
    return not (self == other)
18214 
 
18215 
class addOrUpdateBrandInfo_result:
18216 
 
18217 
  thrift_spec = (
18218 
  )
18219 
 
18220 
  def read(self, iprot):
18221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18223 
      return
18224 
    iprot.readStructBegin()
18225 
    while True:
18226 
      (fname, ftype, fid) = iprot.readFieldBegin()
18227 
      if ftype == TType.STOP:
18228 
        break
18229 
      else:
18230 
        iprot.skip(ftype)
18231 
      iprot.readFieldEnd()
18232 
    iprot.readStructEnd()
18233 
 
18234 
  def write(self, oprot):
18235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18237 
      return
18238 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18239 
    oprot.writeFieldStop()
18240 
    oprot.writeStructEnd()
18241 
 
18242 
  def validate(self):
18243 
    return
18244 
 
18245 
 
18246 
  def __repr__(self):
18247 
    L = ['%s=%r' % (key, value)
18248 
      for key, value in self.__dict__.iteritems()]
18249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18250 
 
18251 
  def __eq__(self, other):
18252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18253 
 
18254 
  def __ne__(self, other):
18255 
    return not (self == other)
18256 
 
18257 
class getBrandInfo_args:
18258 
 
18259 
  thrift_spec = (
18260 
  )
18261 
 
18262 
  def read(self, iprot):
18263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18265 
      return
18266 
    iprot.readStructBegin()
18267 
    while True:
18268 
      (fname, ftype, fid) = iprot.readFieldBegin()
18269 
      if ftype == TType.STOP:
18270 
        break
18271 
      else:
18272 
        iprot.skip(ftype)
18273 
      iprot.readFieldEnd()
18274 
    iprot.readStructEnd()
18275 
 
18276 
  def write(self, oprot):
18277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18279 
      return
18280 
    oprot.writeStructBegin('getBrandInfo_args')
18281 
    oprot.writeFieldStop()
18282 
    oprot.writeStructEnd()
18283 
 
18284 
  def validate(self):
18285 
    return
18286 
 
18287 
 
18288 
  def __repr__(self):
18289 
    L = ['%s=%r' % (key, value)
18290 
      for key, value in self.__dict__.iteritems()]
18291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18292 
 
18293 
  def __eq__(self, other):
18294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18295 
 
18296 
  def __ne__(self, other):
18297 
    return not (self == other)
18298 
 
18299 
class getBrandInfo_result:
18300 
  """
18301 
  Attributes:
18302 
   - success
18303 
  """
18304 
 
18305 
  thrift_spec = (
18306 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
18307 
  )
18308 
 
18309 
  def __init__(self, success=None,):
18310 
    self.success = success
18311 
 
18312 
  def read(self, iprot):
18313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18315 
      return
18316 
    iprot.readStructBegin()
18317 
    while True:
18318 
      (fname, ftype, fid) = iprot.readFieldBegin()
18319 
      if ftype == TType.STOP:
18320 
        break
18321 
      if fid == 0:
18322 
        if ftype == TType.MAP:
18323 
          self.success = {}
8590 kshitij.so 18324 
          (_ktype373, _vtype374, _size372 ) = iprot.readMapBegin()
18325 
          for _i376 in xrange(_size372):
18326 
            _key377 = iprot.readString();
18327 
            _val378 = BrandInfo()
18328 
            _val378.read(iprot)
18329 
            self.success[_key377] = _val378
7272 amit.gupta 18330 
          iprot.readMapEnd()
18331 
        else:
18332 
          iprot.skip(ftype)
18333 
      else:
18334 
        iprot.skip(ftype)
18335 
      iprot.readFieldEnd()
18336 
    iprot.readStructEnd()
18337 
 
18338 
  def write(self, oprot):
18339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18341 
      return
18342 
    oprot.writeStructBegin('getBrandInfo_result')
18343 
    if self.success is not None:
18344 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18345 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
8590 kshitij.so 18346 
      for kiter379,viter380 in self.success.items():
18347 
        oprot.writeString(kiter379)
18348 
        viter380.write(oprot)
7272 amit.gupta 18349 
      oprot.writeMapEnd()
18350 
      oprot.writeFieldEnd()
18351 
    oprot.writeFieldStop()
18352 
    oprot.writeStructEnd()
18353 
 
18354 
  def validate(self):
18355 
    return
18356 
 
18357 
 
18358 
  def __repr__(self):
18359 
    L = ['%s=%r' % (key, value)
18360 
      for key, value in self.__dict__.iteritems()]
18361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18362 
 
18363 
  def __eq__(self, other):
18364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18365 
 
18366 
  def __ne__(self, other):
18367 
    return not (self == other)
18368 
 
7256 rajveer 18369 
class getStorePricing_args:
18370 
  """
18371 
  Attributes:
18372 
   - itemId
18373 
  """
18374 
 
18375 
  thrift_spec = (
18376 
    None, # 0
18377 
    (1, TType.I64, 'itemId', None, None, ), # 1
18378 
  )
18379 
 
18380 
  def __init__(self, itemId=None,):
18381 
    self.itemId = itemId
18382 
 
18383 
  def read(self, iprot):
18384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18386 
      return
18387 
    iprot.readStructBegin()
18388 
    while True:
18389 
      (fname, ftype, fid) = iprot.readFieldBegin()
18390 
      if ftype == TType.STOP:
18391 
        break
18392 
      if fid == 1:
18393 
        if ftype == TType.I64:
18394 
          self.itemId = iprot.readI64();
18395 
        else:
18396 
          iprot.skip(ftype)
18397 
      else:
18398 
        iprot.skip(ftype)
18399 
      iprot.readFieldEnd()
18400 
    iprot.readStructEnd()
18401 
 
18402 
  def write(self, oprot):
18403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18405 
      return
18406 
    oprot.writeStructBegin('getStorePricing_args')
18407 
    if self.itemId is not None:
18408 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18409 
      oprot.writeI64(self.itemId)
18410 
      oprot.writeFieldEnd()
18411 
    oprot.writeFieldStop()
18412 
    oprot.writeStructEnd()
18413 
 
18414 
  def validate(self):
18415 
    return
18416 
 
18417 
 
18418 
  def __repr__(self):
18419 
    L = ['%s=%r' % (key, value)
18420 
      for key, value in self.__dict__.iteritems()]
18421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18422 
 
18423 
  def __eq__(self, other):
18424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18425 
 
18426 
  def __ne__(self, other):
18427 
    return not (self == other)
18428 
 
18429 
class getStorePricing_result:
18430 
  """
18431 
  Attributes:
18432 
   - success
18433 
  """
18434 
 
18435 
  thrift_spec = (
18436 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
18437 
  )
18438 
 
18439 
  def __init__(self, success=None,):
18440 
    self.success = success
18441 
 
18442 
  def read(self, iprot):
18443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18445 
      return
18446 
    iprot.readStructBegin()
18447 
    while True:
18448 
      (fname, ftype, fid) = iprot.readFieldBegin()
18449 
      if ftype == TType.STOP:
18450 
        break
18451 
      if fid == 0:
18452 
        if ftype == TType.STRUCT:
18453 
          self.success = StorePricing()
18454 
          self.success.read(iprot)
18455 
        else:
18456 
          iprot.skip(ftype)
18457 
      else:
18458 
        iprot.skip(ftype)
18459 
      iprot.readFieldEnd()
18460 
    iprot.readStructEnd()
18461 
 
18462 
  def write(self, oprot):
18463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18465 
      return
18466 
    oprot.writeStructBegin('getStorePricing_result')
18467 
    if self.success is not None:
18468 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18469 
      self.success.write(oprot)
18470 
      oprot.writeFieldEnd()
18471 
    oprot.writeFieldStop()
18472 
    oprot.writeStructEnd()
18473 
 
18474 
  def validate(self):
18475 
    return
18476 
 
18477 
 
18478 
  def __repr__(self):
18479 
    L = ['%s=%r' % (key, value)
18480 
      for key, value in self.__dict__.iteritems()]
18481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18482 
 
18483 
  def __eq__(self, other):
18484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18485 
 
18486 
  def __ne__(self, other):
18487 
    return not (self == other)
7265 rajveer 18488 
 
7306 rajveer 18489 
class getStorePricings_args:
18490 
  """
18491 
  Attributes:
18492 
   - itemIds
18493 
  """
18494 
 
18495 
  thrift_spec = (
18496 
    None, # 0
18497 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18498 
  )
18499 
 
18500 
  def __init__(self, itemIds=None,):
18501 
    self.itemIds = itemIds
18502 
 
18503 
  def read(self, iprot):
18504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18506 
      return
18507 
    iprot.readStructBegin()
18508 
    while True:
18509 
      (fname, ftype, fid) = iprot.readFieldBegin()
18510 
      if ftype == TType.STOP:
18511 
        break
18512 
      if fid == 1:
18513 
        if ftype == TType.LIST:
18514 
          self.itemIds = []
8590 kshitij.so 18515 
          (_etype384, _size381) = iprot.readListBegin()
18516 
          for _i385 in xrange(_size381):
18517 
            _elem386 = iprot.readI64();
18518 
            self.itemIds.append(_elem386)
7306 rajveer 18519 
          iprot.readListEnd()
18520 
        else:
18521 
          iprot.skip(ftype)
18522 
      else:
18523 
        iprot.skip(ftype)
18524 
      iprot.readFieldEnd()
18525 
    iprot.readStructEnd()
18526 
 
18527 
  def write(self, oprot):
18528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18530 
      return
18531 
    oprot.writeStructBegin('getStorePricings_args')
18532 
    if self.itemIds is not None:
18533 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18534 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 18535 
      for iter387 in self.itemIds:
18536 
        oprot.writeI64(iter387)
7306 rajveer 18537 
      oprot.writeListEnd()
18538 
      oprot.writeFieldEnd()
18539 
    oprot.writeFieldStop()
18540 
    oprot.writeStructEnd()
18541 
 
18542 
  def validate(self):
18543 
    return
18544 
 
18545 
 
18546 
  def __repr__(self):
18547 
    L = ['%s=%r' % (key, value)
18548 
      for key, value in self.__dict__.iteritems()]
18549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18550 
 
18551 
  def __eq__(self, other):
18552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18553 
 
18554 
  def __ne__(self, other):
18555 
    return not (self == other)
18556 
 
18557 
class getStorePricings_result:
18558 
  """
18559 
  Attributes:
18560 
   - success
18561 
  """
18562 
 
18563 
  thrift_spec = (
18564 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
18565 
  )
18566 
 
18567 
  def __init__(self, success=None,):
18568 
    self.success = success
18569 
 
18570 
  def read(self, iprot):
18571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18573 
      return
18574 
    iprot.readStructBegin()
18575 
    while True:
18576 
      (fname, ftype, fid) = iprot.readFieldBegin()
18577 
      if ftype == TType.STOP:
18578 
        break
18579 
      if fid == 0:
18580 
        if ftype == TType.LIST:
18581 
          self.success = []
8590 kshitij.so 18582 
          (_etype391, _size388) = iprot.readListBegin()
18583 
          for _i392 in xrange(_size388):
18584 
            _elem393 = StorePricing()
18585 
            _elem393.read(iprot)
18586 
            self.success.append(_elem393)
7306 rajveer 18587 
          iprot.readListEnd()
18588 
        else:
18589 
          iprot.skip(ftype)
18590 
      else:
18591 
        iprot.skip(ftype)
18592 
      iprot.readFieldEnd()
18593 
    iprot.readStructEnd()
18594 
 
18595 
  def write(self, oprot):
18596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18598 
      return
18599 
    oprot.writeStructBegin('getStorePricings_result')
18600 
    if self.success is not None:
18601 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18602 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18603 
      for iter394 in self.success:
18604 
        iter394.write(oprot)
7306 rajveer 18605 
      oprot.writeListEnd()
18606 
      oprot.writeFieldEnd()
18607 
    oprot.writeFieldStop()
18608 
    oprot.writeStructEnd()
18609 
 
18610 
  def validate(self):
18611 
    return
18612 
 
18613 
 
18614 
  def __repr__(self):
18615 
    L = ['%s=%r' % (key, value)
18616 
      for key, value in self.__dict__.iteritems()]
18617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18618 
 
18619 
  def __eq__(self, other):
18620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18621 
 
18622 
  def __ne__(self, other):
18623 
    return not (self == other)
18624 
 
7265 rajveer 18625 
class updateStorePricing_args:
18626 
  """
18627 
  Attributes:
18628 
   - sp
7382 rajveer 18629 
   - allColors
7265 rajveer 18630 
  """
18631 
 
18632 
  thrift_spec = (
18633 
    None, # 0
18634 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 18635 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 18636 
  )
18637 
 
7382 rajveer 18638 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 18639 
    self.sp = sp
7382 rajveer 18640 
    self.allColors = allColors
7265 rajveer 18641 
 
18642 
  def read(self, iprot):
18643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18645 
      return
18646 
    iprot.readStructBegin()
18647 
    while True:
18648 
      (fname, ftype, fid) = iprot.readFieldBegin()
18649 
      if ftype == TType.STOP:
18650 
        break
18651 
      if fid == 1:
18652 
        if ftype == TType.STRUCT:
18653 
          self.sp = StorePricing()
18654 
          self.sp.read(iprot)
18655 
        else:
18656 
          iprot.skip(ftype)
7382 rajveer 18657 
      elif fid == 2:
18658 
        if ftype == TType.BOOL:
18659 
          self.allColors = iprot.readBool();
18660 
        else:
18661 
          iprot.skip(ftype)
7265 rajveer 18662 
      else:
18663 
        iprot.skip(ftype)
18664 
      iprot.readFieldEnd()
18665 
    iprot.readStructEnd()
18666 
 
18667 
  def write(self, oprot):
18668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18670 
      return
18671 
    oprot.writeStructBegin('updateStorePricing_args')
18672 
    if self.sp is not None:
18673 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
18674 
      self.sp.write(oprot)
18675 
      oprot.writeFieldEnd()
7382 rajveer 18676 
    if self.allColors is not None:
18677 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
18678 
      oprot.writeBool(self.allColors)
18679 
      oprot.writeFieldEnd()
7265 rajveer 18680 
    oprot.writeFieldStop()
18681 
    oprot.writeStructEnd()
18682 
 
18683 
  def validate(self):
18684 
    return
18685 
 
18686 
 
18687 
  def __repr__(self):
18688 
    L = ['%s=%r' % (key, value)
18689 
      for key, value in self.__dict__.iteritems()]
18690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18691 
 
18692 
  def __eq__(self, other):
18693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18694 
 
18695 
  def __ne__(self, other):
18696 
    return not (self == other)
18697 
 
18698 
class updateStorePricing_result:
18699 
 
18700 
  thrift_spec = (
18701 
  )
18702 
 
18703 
  def read(self, iprot):
18704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18706 
      return
18707 
    iprot.readStructBegin()
18708 
    while True:
18709 
      (fname, ftype, fid) = iprot.readFieldBegin()
18710 
      if ftype == TType.STOP:
18711 
        break
18712 
      else:
18713 
        iprot.skip(ftype)
18714 
      iprot.readFieldEnd()
18715 
    iprot.readStructEnd()
18716 
 
18717 
  def write(self, oprot):
18718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18720 
      return
18721 
    oprot.writeStructBegin('updateStorePricing_result')
18722 
    oprot.writeFieldStop()
18723 
    oprot.writeStructEnd()
18724 
 
18725 
  def validate(self):
18726 
    return
18727 
 
18728 
 
18729 
  def __repr__(self):
18730 
    L = ['%s=%r' % (key, value)
18731 
      for key, value in self.__dict__.iteritems()]
18732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18733 
 
18734 
  def __eq__(self, other):
18735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18736 
 
18737 
  def __ne__(self, other):
18738 
    return not (self == other)
7281 kshitij.so 18739 
 
18740 
class getAllAmazonListedItems_args:
18741 
 
18742 
  thrift_spec = (
18743 
  )
18744 
 
18745 
  def read(self, iprot):
18746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18748 
      return
18749 
    iprot.readStructBegin()
18750 
    while True:
18751 
      (fname, ftype, fid) = iprot.readFieldBegin()
18752 
      if ftype == TType.STOP:
18753 
        break
18754 
      else:
18755 
        iprot.skip(ftype)
18756 
      iprot.readFieldEnd()
18757 
    iprot.readStructEnd()
18758 
 
18759 
  def write(self, oprot):
18760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18762 
      return
18763 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
18764 
    oprot.writeFieldStop()
18765 
    oprot.writeStructEnd()
18766 
 
18767 
  def validate(self):
18768 
    return
18769 
 
18770 
 
18771 
  def __repr__(self):
18772 
    L = ['%s=%r' % (key, value)
18773 
      for key, value in self.__dict__.iteritems()]
18774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18775 
 
18776 
  def __eq__(self, other):
18777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18778 
 
18779 
  def __ne__(self, other):
18780 
    return not (self == other)
18781 
 
18782 
class getAllAmazonListedItems_result:
18783 
  """
18784 
  Attributes:
18785 
   - success
18786 
  """
18787 
 
18788 
  thrift_spec = (
18789 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18790 
  )
18791 
 
18792 
  def __init__(self, success=None,):
18793 
    self.success = success
18794 
 
18795 
  def read(self, iprot):
18796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18798 
      return
18799 
    iprot.readStructBegin()
18800 
    while True:
18801 
      (fname, ftype, fid) = iprot.readFieldBegin()
18802 
      if ftype == TType.STOP:
18803 
        break
18804 
      if fid == 0:
18805 
        if ftype == TType.LIST:
18806 
          self.success = []
8590 kshitij.so 18807 
          (_etype398, _size395) = iprot.readListBegin()
18808 
          for _i399 in xrange(_size395):
18809 
            _elem400 = Amazonlisted()
18810 
            _elem400.read(iprot)
18811 
            self.success.append(_elem400)
7281 kshitij.so 18812 
          iprot.readListEnd()
18813 
        else:
18814 
          iprot.skip(ftype)
18815 
      else:
18816 
        iprot.skip(ftype)
18817 
      iprot.readFieldEnd()
18818 
    iprot.readStructEnd()
18819 
 
18820 
  def write(self, oprot):
18821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18823 
      return
18824 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
18825 
    if self.success is not None:
18826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18827 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18828 
      for iter401 in self.success:
18829 
        iter401.write(oprot)
7281 kshitij.so 18830 
      oprot.writeListEnd()
18831 
      oprot.writeFieldEnd()
18832 
    oprot.writeFieldStop()
18833 
    oprot.writeStructEnd()
18834 
 
18835 
  def validate(self):
18836 
    return
18837 
 
18838 
 
18839 
  def __repr__(self):
18840 
    L = ['%s=%r' % (key, value)
18841 
      for key, value in self.__dict__.iteritems()]
18842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18843 
 
18844 
  def __eq__(self, other):
18845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18846 
 
18847 
  def __ne__(self, other):
18848 
    return not (self == other)
18849 
 
18850 
class getAmazonItemDetails_args:
18851 
  """
18852 
  Attributes:
18853 
   - itemId
18854 
  """
18855 
 
18856 
  thrift_spec = (
18857 
    None, # 0
18858 
    (1, TType.I64, 'itemId', None, None, ), # 1
18859 
  )
18860 
 
18861 
  def __init__(self, itemId=None,):
18862 
    self.itemId = itemId
18863 
 
18864 
  def read(self, iprot):
18865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18867 
      return
18868 
    iprot.readStructBegin()
18869 
    while True:
18870 
      (fname, ftype, fid) = iprot.readFieldBegin()
18871 
      if ftype == TType.STOP:
18872 
        break
18873 
      if fid == 1:
18874 
        if ftype == TType.I64:
18875 
          self.itemId = iprot.readI64();
18876 
        else:
18877 
          iprot.skip(ftype)
18878 
      else:
18879 
        iprot.skip(ftype)
18880 
      iprot.readFieldEnd()
18881 
    iprot.readStructEnd()
18882 
 
18883 
  def write(self, oprot):
18884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18886 
      return
18887 
    oprot.writeStructBegin('getAmazonItemDetails_args')
18888 
    if self.itemId is not None:
18889 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18890 
      oprot.writeI64(self.itemId)
18891 
      oprot.writeFieldEnd()
18892 
    oprot.writeFieldStop()
18893 
    oprot.writeStructEnd()
18894 
 
18895 
  def validate(self):
18896 
    return
18897 
 
18898 
 
18899 
  def __repr__(self):
18900 
    L = ['%s=%r' % (key, value)
18901 
      for key, value in self.__dict__.iteritems()]
18902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18903 
 
18904 
  def __eq__(self, other):
18905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18906 
 
18907 
  def __ne__(self, other):
18908 
    return not (self == other)
18909 
 
18910 
class getAmazonItemDetails_result:
18911 
  """
18912 
  Attributes:
18913 
   - success
18914 
  """
18915 
 
18916 
  thrift_spec = (
18917 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
18918 
  )
18919 
 
18920 
  def __init__(self, success=None,):
18921 
    self.success = success
18922 
 
18923 
  def read(self, iprot):
18924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18926 
      return
18927 
    iprot.readStructBegin()
18928 
    while True:
18929 
      (fname, ftype, fid) = iprot.readFieldBegin()
18930 
      if ftype == TType.STOP:
18931 
        break
18932 
      if fid == 0:
18933 
        if ftype == TType.STRUCT:
18934 
          self.success = Amazonlisted()
18935 
          self.success.read(iprot)
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      else:
18939 
        iprot.skip(ftype)
18940 
      iprot.readFieldEnd()
18941 
    iprot.readStructEnd()
18942 
 
18943 
  def write(self, oprot):
18944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18946 
      return
18947 
    oprot.writeStructBegin('getAmazonItemDetails_result')
18948 
    if self.success is not None:
18949 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18950 
      self.success.write(oprot)
18951 
      oprot.writeFieldEnd()
18952 
    oprot.writeFieldStop()
18953 
    oprot.writeStructEnd()
18954 
 
18955 
  def validate(self):
18956 
    return
18957 
 
18958 
 
18959 
  def __repr__(self):
18960 
    L = ['%s=%r' % (key, value)
18961 
      for key, value in self.__dict__.iteritems()]
18962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18963 
 
18964 
  def __eq__(self, other):
18965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18966 
 
18967 
  def __ne__(self, other):
18968 
    return not (self == other)
18969 
 
18970 
class updateAmazonItemDetails_args:
18971 
  """
18972 
  Attributes:
8168 kshitij.so 18973 
   - amazonlisted
7281 kshitij.so 18974 
  """
18975 
 
18976 
  thrift_spec = (
18977 
    None, # 0
8168 kshitij.so 18978 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 18979 
  )
18980 
 
8168 kshitij.so 18981 
  def __init__(self, amazonlisted=None,):
18982 
    self.amazonlisted = amazonlisted
7281 kshitij.so 18983 
 
18984 
  def read(self, iprot):
18985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18987 
      return
18988 
    iprot.readStructBegin()
18989 
    while True:
18990 
      (fname, ftype, fid) = iprot.readFieldBegin()
18991 
      if ftype == TType.STOP:
18992 
        break
18993 
      if fid == 1:
8168 kshitij.so 18994 
        if ftype == TType.STRUCT:
18995 
          self.amazonlisted = Amazonlisted()
18996 
          self.amazonlisted.read(iprot)
7281 kshitij.so 18997 
        else:
18998 
          iprot.skip(ftype)
18999 
      else:
19000 
        iprot.skip(ftype)
19001 
      iprot.readFieldEnd()
19002 
    iprot.readStructEnd()
19003 
 
19004 
  def write(self, oprot):
19005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19007 
      return
19008 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 19009 
    if self.amazonlisted is not None:
19010 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19011 
      self.amazonlisted.write(oprot)
7281 kshitij.so 19012 
      oprot.writeFieldEnd()
19013 
    oprot.writeFieldStop()
19014 
    oprot.writeStructEnd()
19015 
 
19016 
  def validate(self):
19017 
    return
19018 
 
19019 
 
19020 
  def __repr__(self):
19021 
    L = ['%s=%r' % (key, value)
19022 
      for key, value in self.__dict__.iteritems()]
19023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19024 
 
19025 
  def __eq__(self, other):
19026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19027 
 
19028 
  def __ne__(self, other):
19029 
    return not (self == other)
19030 
 
19031 
class updateAmazonItemDetails_result:
19032 
 
19033 
  thrift_spec = (
19034 
  )
19035 
 
19036 
  def read(self, iprot):
19037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19039 
      return
19040 
    iprot.readStructBegin()
19041 
    while True:
19042 
      (fname, ftype, fid) = iprot.readFieldBegin()
19043 
      if ftype == TType.STOP:
19044 
        break
19045 
      else:
19046 
        iprot.skip(ftype)
19047 
      iprot.readFieldEnd()
19048 
    iprot.readStructEnd()
19049 
 
19050 
  def write(self, oprot):
19051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19053 
      return
19054 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
19055 
    oprot.writeFieldStop()
19056 
    oprot.writeStructEnd()
19057 
 
19058 
  def validate(self):
19059 
    return
19060 
 
19061 
 
19062 
  def __repr__(self):
19063 
    L = ['%s=%r' % (key, value)
19064 
      for key, value in self.__dict__.iteritems()]
19065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19066 
 
19067 
  def __eq__(self, other):
19068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19069 
 
19070 
  def __ne__(self, other):
19071 
    return not (self == other)
19072 
 
19073 
class addAmazonItem_args:
19074 
  """
19075 
  Attributes:
19076 
   - amazonlisted
19077 
  """
19078 
 
19079 
  thrift_spec = (
19080 
    None, # 0
19081 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
19082 
  )
19083 
 
19084 
  def __init__(self, amazonlisted=None,):
19085 
    self.amazonlisted = amazonlisted
19086 
 
19087 
  def read(self, iprot):
19088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19090 
      return
19091 
    iprot.readStructBegin()
19092 
    while True:
19093 
      (fname, ftype, fid) = iprot.readFieldBegin()
19094 
      if ftype == TType.STOP:
19095 
        break
19096 
      if fid == 1:
19097 
        if ftype == TType.STRUCT:
19098 
          self.amazonlisted = Amazonlisted()
19099 
          self.amazonlisted.read(iprot)
19100 
        else:
19101 
          iprot.skip(ftype)
19102 
      else:
19103 
        iprot.skip(ftype)
19104 
      iprot.readFieldEnd()
19105 
    iprot.readStructEnd()
19106 
 
19107 
  def write(self, oprot):
19108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19110 
      return
19111 
    oprot.writeStructBegin('addAmazonItem_args')
19112 
    if self.amazonlisted is not None:
19113 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19114 
      self.amazonlisted.write(oprot)
19115 
      oprot.writeFieldEnd()
19116 
    oprot.writeFieldStop()
19117 
    oprot.writeStructEnd()
19118 
 
19119 
  def validate(self):
19120 
    return
19121 
 
19122 
 
19123 
  def __repr__(self):
19124 
    L = ['%s=%r' % (key, value)
19125 
      for key, value in self.__dict__.iteritems()]
19126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19127 
 
19128 
  def __eq__(self, other):
19129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19130 
 
19131 
  def __ne__(self, other):
19132 
    return not (self == other)
19133 
 
19134 
class addAmazonItem_result:
19135 
 
19136 
  thrift_spec = (
19137 
  )
19138 
 
19139 
  def read(self, iprot):
19140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19142 
      return
19143 
    iprot.readStructBegin()
19144 
    while True:
19145 
      (fname, ftype, fid) = iprot.readFieldBegin()
19146 
      if ftype == TType.STOP:
19147 
        break
19148 
      else:
19149 
        iprot.skip(ftype)
19150 
      iprot.readFieldEnd()
19151 
    iprot.readStructEnd()
19152 
 
19153 
  def write(self, oprot):
19154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19156 
      return
19157 
    oprot.writeStructBegin('addAmazonItem_result')
19158 
    oprot.writeFieldStop()
19159 
    oprot.writeStructEnd()
19160 
 
19161 
  def validate(self):
19162 
    return
19163 
 
19164 
 
19165 
  def __repr__(self):
19166 
    L = ['%s=%r' % (key, value)
19167 
      for key, value in self.__dict__.iteritems()]
19168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19169 
 
19170 
  def __eq__(self, other):
19171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19172 
 
19173 
  def __ne__(self, other):
19174 
    return not (self == other)
7291 vikram.rag 19175 
 
19176 
class getAsinItems_args:
19177 
 
19178 
  thrift_spec = (
19179 
  )
19180 
 
19181 
  def read(self, iprot):
19182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19184 
      return
19185 
    iprot.readStructBegin()
19186 
    while True:
19187 
      (fname, ftype, fid) = iprot.readFieldBegin()
19188 
      if ftype == TType.STOP:
19189 
        break
19190 
      else:
19191 
        iprot.skip(ftype)
19192 
      iprot.readFieldEnd()
19193 
    iprot.readStructEnd()
19194 
 
19195 
  def write(self, oprot):
19196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19198 
      return
19199 
    oprot.writeStructBegin('getAsinItems_args')
19200 
    oprot.writeFieldStop()
19201 
    oprot.writeStructEnd()
19202 
 
19203 
  def validate(self):
19204 
    return
19205 
 
19206 
 
19207 
  def __repr__(self):
19208 
    L = ['%s=%r' % (key, value)
19209 
      for key, value in self.__dict__.iteritems()]
19210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19211 
 
19212 
  def __eq__(self, other):
19213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19214 
 
19215 
  def __ne__(self, other):
19216 
    return not (self == other)
19217 
 
19218 
class getAsinItems_result:
19219 
  """
19220 
  Attributes:
19221 
   - success
19222 
  """
19223 
 
19224 
  thrift_spec = (
19225 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19226 
  )
19227 
 
19228 
  def __init__(self, success=None,):
19229 
    self.success = success
19230 
 
19231 
  def read(self, iprot):
19232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19234 
      return
19235 
    iprot.readStructBegin()
19236 
    while True:
19237 
      (fname, ftype, fid) = iprot.readFieldBegin()
19238 
      if ftype == TType.STOP:
19239 
        break
19240 
      if fid == 0:
19241 
        if ftype == TType.LIST:
19242 
          self.success = []
8590 kshitij.so 19243 
          (_etype405, _size402) = iprot.readListBegin()
19244 
          for _i406 in xrange(_size402):
19245 
            _elem407 = Item()
19246 
            _elem407.read(iprot)
19247 
            self.success.append(_elem407)
7291 vikram.rag 19248 
          iprot.readListEnd()
19249 
        else:
19250 
          iprot.skip(ftype)
19251 
      else:
19252 
        iprot.skip(ftype)
19253 
      iprot.readFieldEnd()
19254 
    iprot.readStructEnd()
19255 
 
19256 
  def write(self, oprot):
19257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19259 
      return
19260 
    oprot.writeStructBegin('getAsinItems_result')
19261 
    if self.success is not None:
19262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19263 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19264 
      for iter408 in self.success:
19265 
        iter408.write(oprot)
7291 vikram.rag 19266 
      oprot.writeListEnd()
19267 
      oprot.writeFieldEnd()
19268 
    oprot.writeFieldStop()
19269 
    oprot.writeStructEnd()
19270 
 
19271 
  def validate(self):
19272 
    return
19273 
 
19274 
 
19275 
  def __repr__(self):
19276 
    L = ['%s=%r' % (key, value)
19277 
      for key, value in self.__dict__.iteritems()]
19278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19279 
 
19280 
  def __eq__(self, other):
19281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19282 
 
19283 
  def __ne__(self, other):
19284 
    return not (self == other)
19285 
 
19286 
class getAllFbaListedItems_args:
19287 
 
19288 
  thrift_spec = (
19289 
  )
19290 
 
19291 
  def read(self, iprot):
19292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19294 
      return
19295 
    iprot.readStructBegin()
19296 
    while True:
19297 
      (fname, ftype, fid) = iprot.readFieldBegin()
19298 
      if ftype == TType.STOP:
19299 
        break
19300 
      else:
19301 
        iprot.skip(ftype)
19302 
      iprot.readFieldEnd()
19303 
    iprot.readStructEnd()
19304 
 
19305 
  def write(self, oprot):
19306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19308 
      return
19309 
    oprot.writeStructBegin('getAllFbaListedItems_args')
19310 
    oprot.writeFieldStop()
19311 
    oprot.writeStructEnd()
19312 
 
19313 
  def validate(self):
19314 
    return
19315 
 
19316 
 
19317 
  def __repr__(self):
19318 
    L = ['%s=%r' % (key, value)
19319 
      for key, value in self.__dict__.iteritems()]
19320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19321 
 
19322 
  def __eq__(self, other):
19323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19324 
 
19325 
  def __ne__(self, other):
19326 
    return not (self == other)
19327 
 
19328 
class getAllFbaListedItems_result:
19329 
  """
19330 
  Attributes:
19331 
   - success
19332 
  """
19333 
 
19334 
  thrift_spec = (
19335 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19336 
  )
19337 
 
19338 
  def __init__(self, success=None,):
19339 
    self.success = success
19340 
 
19341 
  def read(self, iprot):
19342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19344 
      return
19345 
    iprot.readStructBegin()
19346 
    while True:
19347 
      (fname, ftype, fid) = iprot.readFieldBegin()
19348 
      if ftype == TType.STOP:
19349 
        break
19350 
      if fid == 0:
19351 
        if ftype == TType.LIST:
19352 
          self.success = []
8590 kshitij.so 19353 
          (_etype412, _size409) = iprot.readListBegin()
19354 
          for _i413 in xrange(_size409):
19355 
            _elem414 = Amazonlisted()
19356 
            _elem414.read(iprot)
19357 
            self.success.append(_elem414)
7291 vikram.rag 19358 
          iprot.readListEnd()
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('getAllFbaListedItems_result')
19371 
    if self.success is not None:
19372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19374 
      for iter415 in self.success:
19375 
        iter415.write(oprot)
7291 vikram.rag 19376 
      oprot.writeListEnd()
19377 
      oprot.writeFieldEnd()
19378 
    oprot.writeFieldStop()
19379 
    oprot.writeStructEnd()
19380 
 
19381 
  def validate(self):
19382 
    return
19383 
 
19384 
 
19385 
  def __repr__(self):
19386 
    L = ['%s=%r' % (key, value)
19387 
      for key, value in self.__dict__.iteritems()]
19388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19389 
 
19390 
  def __eq__(self, other):
19391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19392 
 
19393 
  def __ne__(self, other):
19394 
    return not (self == other)
19395 
 
19396 
class getAllNonFbaListedItems_args:
19397 
 
19398 
  thrift_spec = (
19399 
  )
19400 
 
19401 
  def read(self, iprot):
19402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19404 
      return
19405 
    iprot.readStructBegin()
19406 
    while True:
19407 
      (fname, ftype, fid) = iprot.readFieldBegin()
19408 
      if ftype == TType.STOP:
19409 
        break
19410 
      else:
19411 
        iprot.skip(ftype)
19412 
      iprot.readFieldEnd()
19413 
    iprot.readStructEnd()
19414 
 
19415 
  def write(self, oprot):
19416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19418 
      return
19419 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
19420 
    oprot.writeFieldStop()
19421 
    oprot.writeStructEnd()
19422 
 
19423 
  def validate(self):
19424 
    return
19425 
 
19426 
 
19427 
  def __repr__(self):
19428 
    L = ['%s=%r' % (key, value)
19429 
      for key, value in self.__dict__.iteritems()]
19430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19431 
 
19432 
  def __eq__(self, other):
19433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19434 
 
19435 
  def __ne__(self, other):
19436 
    return not (self == other)
19437 
 
19438 
class getAllNonFbaListedItems_result:
19439 
  """
19440 
  Attributes:
19441 
   - success
19442 
  """
19443 
 
19444 
  thrift_spec = (
19445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19446 
  )
19447 
 
19448 
  def __init__(self, success=None,):
19449 
    self.success = success
19450 
 
19451 
  def read(self, iprot):
19452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19454 
      return
19455 
    iprot.readStructBegin()
19456 
    while True:
19457 
      (fname, ftype, fid) = iprot.readFieldBegin()
19458 
      if ftype == TType.STOP:
19459 
        break
19460 
      if fid == 0:
19461 
        if ftype == TType.LIST:
19462 
          self.success = []
8590 kshitij.so 19463 
          (_etype419, _size416) = iprot.readListBegin()
19464 
          for _i420 in xrange(_size416):
19465 
            _elem421 = Amazonlisted()
19466 
            _elem421.read(iprot)
19467 
            self.success.append(_elem421)
7291 vikram.rag 19468 
          iprot.readListEnd()
19469 
        else:
19470 
          iprot.skip(ftype)
19471 
      else:
19472 
        iprot.skip(ftype)
19473 
      iprot.readFieldEnd()
19474 
    iprot.readStructEnd()
19475 
 
19476 
  def write(self, oprot):
19477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19479 
      return
19480 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
19481 
    if self.success is not None:
19482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19484 
      for iter422 in self.success:
19485 
        iter422.write(oprot)
7291 vikram.rag 19486 
      oprot.writeListEnd()
19487 
      oprot.writeFieldEnd()
19488 
    oprot.writeFieldStop()
19489 
    oprot.writeStructEnd()
19490 
 
19491 
  def validate(self):
19492 
    return
19493 
 
19494 
 
19495 
  def __repr__(self):
19496 
    L = ['%s=%r' % (key, value)
19497 
      for key, value in self.__dict__.iteritems()]
19498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19499 
 
19500 
  def __eq__(self, other):
19501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19502 
 
19503 
  def __ne__(self, other):
19504 
    return not (self == other)
7460 kshitij.so 19505 
 
19506 
class updateItemInventory_args:
19507 
  """
19508 
  Attributes:
19509 
   - itemId
19510 
   - holdInventory
19511 
   - defaultInventory
19512 
  """
19513 
 
19514 
  thrift_spec = (
19515 
    None, # 0
19516 
    (1, TType.I64, 'itemId', None, None, ), # 1
19517 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
19518 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
19519 
  )
19520 
 
19521 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
19522 
    self.itemId = itemId
19523 
    self.holdInventory = holdInventory
19524 
    self.defaultInventory = defaultInventory
19525 
 
19526 
  def read(self, iprot):
19527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19529 
      return
19530 
    iprot.readStructBegin()
19531 
    while True:
19532 
      (fname, ftype, fid) = iprot.readFieldBegin()
19533 
      if ftype == TType.STOP:
19534 
        break
19535 
      if fid == 1:
19536 
        if ftype == TType.I64:
19537 
          self.itemId = iprot.readI64();
19538 
        else:
19539 
          iprot.skip(ftype)
19540 
      elif fid == 2:
19541 
        if ftype == TType.I64:
19542 
          self.holdInventory = iprot.readI64();
19543 
        else:
19544 
          iprot.skip(ftype)
19545 
      elif fid == 3:
19546 
        if ftype == TType.I64:
19547 
          self.defaultInventory = iprot.readI64();
19548 
        else:
19549 
          iprot.skip(ftype)
19550 
      else:
19551 
        iprot.skip(ftype)
19552 
      iprot.readFieldEnd()
19553 
    iprot.readStructEnd()
19554 
 
19555 
  def write(self, oprot):
19556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19558 
      return
19559 
    oprot.writeStructBegin('updateItemInventory_args')
19560 
    if self.itemId is not None:
19561 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19562 
      oprot.writeI64(self.itemId)
19563 
      oprot.writeFieldEnd()
19564 
    if self.holdInventory is not None:
19565 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
19566 
      oprot.writeI64(self.holdInventory)
19567 
      oprot.writeFieldEnd()
19568 
    if self.defaultInventory is not None:
19569 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
19570 
      oprot.writeI64(self.defaultInventory)
19571 
      oprot.writeFieldEnd()
19572 
    oprot.writeFieldStop()
19573 
    oprot.writeStructEnd()
19574 
 
19575 
  def validate(self):
19576 
    return
19577 
 
19578 
 
19579 
  def __repr__(self):
19580 
    L = ['%s=%r' % (key, value)
19581 
      for key, value in self.__dict__.iteritems()]
19582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19583 
 
19584 
  def __eq__(self, other):
19585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19586 
 
19587 
  def __ne__(self, other):
19588 
    return not (self == other)
19589 
 
19590 
class updateItemInventory_result:
19591 
  """
19592 
  Attributes:
19593 
   - success
19594 
  """
19595 
 
19596 
  thrift_spec = (
19597 
    (0, TType.BOOL, 'success', None, None, ), # 0
19598 
  )
19599 
 
19600 
  def __init__(self, success=None,):
19601 
    self.success = success
19602 
 
19603 
  def read(self, iprot):
19604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19606 
      return
19607 
    iprot.readStructBegin()
19608 
    while True:
19609 
      (fname, ftype, fid) = iprot.readFieldBegin()
19610 
      if ftype == TType.STOP:
19611 
        break
19612 
      if fid == 0:
19613 
        if ftype == TType.BOOL:
19614 
          self.success = iprot.readBool();
19615 
        else:
19616 
          iprot.skip(ftype)
19617 
      else:
19618 
        iprot.skip(ftype)
19619 
      iprot.readFieldEnd()
19620 
    iprot.readStructEnd()
19621 
 
19622 
  def write(self, oprot):
19623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19625 
      return
19626 
    oprot.writeStructBegin('updateItemInventory_result')
19627 
    if self.success is not None:
19628 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19629 
      oprot.writeBool(self.success)
19630 
      oprot.writeFieldEnd()
19631 
    oprot.writeFieldStop()
19632 
    oprot.writeStructEnd()
19633 
 
19634 
  def validate(self):
19635 
    return
19636 
 
19637 
 
19638 
  def __repr__(self):
19639 
    L = ['%s=%r' % (key, value)
19640 
      for key, value in self.__dict__.iteritems()]
19641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19642 
 
19643 
  def __eq__(self, other):
19644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19645 
 
19646 
  def __ne__(self, other):
19647 
    return not (self == other)
7770 kshitij.so 19648 
 
19649 
class updateTimestampForAmazonFeeds_args:
19650 
  """
19651 
  Attributes:
19652 
   - type
19653 
   - sku
19654 
   - timestamp
19655 
  """
19656 
 
19657 
  thrift_spec = (
19658 
    None, # 0
19659 
    (1, TType.STRING, 'type', None, None, ), # 1
19660 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
19661 
    (3, TType.I64, 'timestamp', None, None, ), # 3
19662 
  )
19663 
 
19664 
  def __init__(self, type=None, sku=None, timestamp=None,):
19665 
    self.type = type
19666 
    self.sku = sku
19667 
    self.timestamp = timestamp
19668 
 
19669 
  def read(self, iprot):
19670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19672 
      return
19673 
    iprot.readStructBegin()
19674 
    while True:
19675 
      (fname, ftype, fid) = iprot.readFieldBegin()
19676 
      if ftype == TType.STOP:
19677 
        break
19678 
      if fid == 1:
19679 
        if ftype == TType.STRING:
19680 
          self.type = iprot.readString();
19681 
        else:
19682 
          iprot.skip(ftype)
19683 
      elif fid == 2:
19684 
        if ftype == TType.LIST:
19685 
          self.sku = []
8590 kshitij.so 19686 
          (_etype426, _size423) = iprot.readListBegin()
19687 
          for _i427 in xrange(_size423):
19688 
            _elem428 = iprot.readI64();
19689 
            self.sku.append(_elem428)
7770 kshitij.so 19690 
          iprot.readListEnd()
19691 
        else:
19692 
          iprot.skip(ftype)
19693 
      elif fid == 3:
19694 
        if ftype == TType.I64:
19695 
          self.timestamp = iprot.readI64();
19696 
        else:
19697 
          iprot.skip(ftype)
19698 
      else:
19699 
        iprot.skip(ftype)
19700 
      iprot.readFieldEnd()
19701 
    iprot.readStructEnd()
19702 
 
19703 
  def write(self, oprot):
19704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19706 
      return
19707 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
19708 
    if self.type is not None:
19709 
      oprot.writeFieldBegin('type', TType.STRING, 1)
19710 
      oprot.writeString(self.type)
19711 
      oprot.writeFieldEnd()
19712 
    if self.sku is not None:
19713 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
19714 
      oprot.writeListBegin(TType.I64, len(self.sku))
8590 kshitij.so 19715 
      for iter429 in self.sku:
19716 
        oprot.writeI64(iter429)
7770 kshitij.so 19717 
      oprot.writeListEnd()
19718 
      oprot.writeFieldEnd()
19719 
    if self.timestamp is not None:
19720 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
19721 
      oprot.writeI64(self.timestamp)
19722 
      oprot.writeFieldEnd()
19723 
    oprot.writeFieldStop()
19724 
    oprot.writeStructEnd()
19725 
 
19726 
  def validate(self):
19727 
    return
19728 
 
19729 
 
19730 
  def __repr__(self):
19731 
    L = ['%s=%r' % (key, value)
19732 
      for key, value in self.__dict__.iteritems()]
19733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19734 
 
19735 
  def __eq__(self, other):
19736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19737 
 
19738 
  def __ne__(self, other):
19739 
    return not (self == other)
19740 
 
19741 
class updateTimestampForAmazonFeeds_result:
19742 
  """
19743 
  Attributes:
19744 
   - success
19745 
  """
19746 
 
19747 
  thrift_spec = (
19748 
    (0, TType.BOOL, 'success', None, None, ), # 0
19749 
  )
19750 
 
19751 
  def __init__(self, success=None,):
19752 
    self.success = success
19753 
 
19754 
  def read(self, iprot):
19755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19757 
      return
19758 
    iprot.readStructBegin()
19759 
    while True:
19760 
      (fname, ftype, fid) = iprot.readFieldBegin()
19761 
      if ftype == TType.STOP:
19762 
        break
19763 
      if fid == 0:
19764 
        if ftype == TType.BOOL:
19765 
          self.success = iprot.readBool();
19766 
        else:
19767 
          iprot.skip(ftype)
19768 
      else:
19769 
        iprot.skip(ftype)
19770 
      iprot.readFieldEnd()
19771 
    iprot.readStructEnd()
19772 
 
19773 
  def write(self, oprot):
19774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19776 
      return
19777 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
19778 
    if self.success is not None:
19779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19780 
      oprot.writeBool(self.success)
19781 
      oprot.writeFieldEnd()
19782 
    oprot.writeFieldStop()
19783 
    oprot.writeStructEnd()
19784 
 
19785 
  def validate(self):
19786 
    return
19787 
 
19788 
 
19789 
  def __repr__(self):
19790 
    L = ['%s=%r' % (key, value)
19791 
      for key, value in self.__dict__.iteritems()]
19792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19793 
 
19794 
  def __eq__(self, other):
19795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19796 
 
19797 
  def __ne__(self, other):
19798 
    return not (self == other)
7897 amar.kumar 19799 
 
19800 
class getAllParentCategories_args:
19801 
 
19802 
  thrift_spec = (
19803 
  )
19804 
 
19805 
  def read(self, iprot):
19806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19808 
      return
19809 
    iprot.readStructBegin()
19810 
    while True:
19811 
      (fname, ftype, fid) = iprot.readFieldBegin()
19812 
      if ftype == TType.STOP:
19813 
        break
19814 
      else:
19815 
        iprot.skip(ftype)
19816 
      iprot.readFieldEnd()
19817 
    iprot.readStructEnd()
19818 
 
19819 
  def write(self, oprot):
19820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19822 
      return
19823 
    oprot.writeStructBegin('getAllParentCategories_args')
19824 
    oprot.writeFieldStop()
19825 
    oprot.writeStructEnd()
19826 
 
19827 
  def validate(self):
19828 
    return
19829 
 
19830 
 
19831 
  def __repr__(self):
19832 
    L = ['%s=%r' % (key, value)
19833 
      for key, value in self.__dict__.iteritems()]
19834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19835 
 
19836 
  def __eq__(self, other):
19837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19838 
 
19839 
  def __ne__(self, other):
19840 
    return not (self == other)
19841 
 
19842 
class getAllParentCategories_result:
19843 
  """
19844 
  Attributes:
19845 
   - success
19846 
  """
19847 
 
19848 
  thrift_spec = (
19849 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
19850 
  )
19851 
 
19852 
  def __init__(self, success=None,):
19853 
    self.success = success
19854 
 
19855 
  def read(self, iprot):
19856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19858 
      return
19859 
    iprot.readStructBegin()
19860 
    while True:
19861 
      (fname, ftype, fid) = iprot.readFieldBegin()
19862 
      if ftype == TType.STOP:
19863 
        break
19864 
      if fid == 0:
19865 
        if ftype == TType.LIST:
19866 
          self.success = []
8590 kshitij.so 19867 
          (_etype433, _size430) = iprot.readListBegin()
19868 
          for _i434 in xrange(_size430):
19869 
            _elem435 = Category()
19870 
            _elem435.read(iprot)
19871 
            self.success.append(_elem435)
7897 amar.kumar 19872 
          iprot.readListEnd()
19873 
        else:
19874 
          iprot.skip(ftype)
19875 
      else:
19876 
        iprot.skip(ftype)
19877 
      iprot.readFieldEnd()
19878 
    iprot.readStructEnd()
19879 
 
19880 
  def write(self, oprot):
19881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19883 
      return
19884 
    oprot.writeStructBegin('getAllParentCategories_result')
19885 
    if self.success is not None:
19886 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19887 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19888 
      for iter436 in self.success:
19889 
        iter436.write(oprot)
7897 amar.kumar 19890 
      oprot.writeListEnd()
19891 
      oprot.writeFieldEnd()
19892 
    oprot.writeFieldStop()
19893 
    oprot.writeStructEnd()
19894 
 
19895 
  def validate(self):
19896 
    return
19897 
 
19898 
 
19899 
  def __repr__(self):
19900 
    L = ['%s=%r' % (key, value)
19901 
      for key, value in self.__dict__.iteritems()]
19902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19903 
 
19904 
  def __eq__(self, other):
19905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19906 
 
19907 
  def __ne__(self, other):
19908 
    return not (self == other)
7977 kshitij.so 19909 
 
19910 
class addPageViewEvent_args:
19911 
  """
19912 
  Attributes:
19913 
   - pageViewEvents
19914 
  """
19915 
 
19916 
  thrift_spec = (
19917 
    None, # 0
19918 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
19919 
  )
19920 
 
19921 
  def __init__(self, pageViewEvents=None,):
19922 
    self.pageViewEvents = pageViewEvents
19923 
 
19924 
  def read(self, iprot):
19925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19927 
      return
19928 
    iprot.readStructBegin()
19929 
    while True:
19930 
      (fname, ftype, fid) = iprot.readFieldBegin()
19931 
      if ftype == TType.STOP:
19932 
        break
19933 
      if fid == 1:
19934 
        if ftype == TType.STRUCT:
19935 
          self.pageViewEvents = PageViewEvents()
19936 
          self.pageViewEvents.read(iprot)
19937 
        else:
19938 
          iprot.skip(ftype)
19939 
      else:
19940 
        iprot.skip(ftype)
19941 
      iprot.readFieldEnd()
19942 
    iprot.readStructEnd()
19943 
 
19944 
  def write(self, oprot):
19945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19947 
      return
19948 
    oprot.writeStructBegin('addPageViewEvent_args')
19949 
    if self.pageViewEvents is not None:
19950 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
19951 
      self.pageViewEvents.write(oprot)
19952 
      oprot.writeFieldEnd()
19953 
    oprot.writeFieldStop()
19954 
    oprot.writeStructEnd()
19955 
 
19956 
  def validate(self):
19957 
    return
19958 
 
19959 
 
19960 
  def __repr__(self):
19961 
    L = ['%s=%r' % (key, value)
19962 
      for key, value in self.__dict__.iteritems()]
19963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19964 
 
19965 
  def __eq__(self, other):
19966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19967 
 
19968 
  def __ne__(self, other):
19969 
    return not (self == other)
19970 
 
19971 
class addPageViewEvent_result:
19972 
 
19973 
  thrift_spec = (
19974 
  )
19975 
 
19976 
  def read(self, iprot):
19977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19979 
      return
19980 
    iprot.readStructBegin()
19981 
    while True:
19982 
      (fname, ftype, fid) = iprot.readFieldBegin()
19983 
      if ftype == TType.STOP:
19984 
        break
19985 
      else:
19986 
        iprot.skip(ftype)
19987 
      iprot.readFieldEnd()
19988 
    iprot.readStructEnd()
19989 
 
19990 
  def write(self, oprot):
19991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19993 
      return
19994 
    oprot.writeStructBegin('addPageViewEvent_result')
19995 
    oprot.writeFieldStop()
19996 
    oprot.writeStructEnd()
19997 
 
19998 
  def validate(self):
19999 
    return
20000 
 
20001 
 
20002 
  def __repr__(self):
20003 
    L = ['%s=%r' % (key, value)
20004 
      for key, value in self.__dict__.iteritems()]
20005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20006 
 
20007 
  def __eq__(self, other):
20008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20009 
 
20010 
  def __ne__(self, other):
20011 
    return not (self == other)
20012 
 
20013 
class addCartEvent_args:
20014 
  """
20015 
  Attributes:
20016 
   - cartEvents
20017 
  """
20018 
 
20019 
  thrift_spec = (
20020 
    None, # 0
20021 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
20022 
  )
20023 
 
20024 
  def __init__(self, cartEvents=None,):
20025 
    self.cartEvents = cartEvents
20026 
 
20027 
  def read(self, iprot):
20028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20030 
      return
20031 
    iprot.readStructBegin()
20032 
    while True:
20033 
      (fname, ftype, fid) = iprot.readFieldBegin()
20034 
      if ftype == TType.STOP:
20035 
        break
20036 
      if fid == 1:
20037 
        if ftype == TType.STRUCT:
20038 
          self.cartEvents = CartEvents()
20039 
          self.cartEvents.read(iprot)
20040 
        else:
20041 
          iprot.skip(ftype)
20042 
      else:
20043 
        iprot.skip(ftype)
20044 
      iprot.readFieldEnd()
20045 
    iprot.readStructEnd()
20046 
 
20047 
  def write(self, oprot):
20048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20050 
      return
20051 
    oprot.writeStructBegin('addCartEvent_args')
20052 
    if self.cartEvents is not None:
20053 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
20054 
      self.cartEvents.write(oprot)
20055 
      oprot.writeFieldEnd()
20056 
    oprot.writeFieldStop()
20057 
    oprot.writeStructEnd()
20058 
 
20059 
  def validate(self):
20060 
    return
20061 
 
20062 
 
20063 
  def __repr__(self):
20064 
    L = ['%s=%r' % (key, value)
20065 
      for key, value in self.__dict__.iteritems()]
20066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20067 
 
20068 
  def __eq__(self, other):
20069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20070 
 
20071 
  def __ne__(self, other):
20072 
    return not (self == other)
20073 
 
20074 
class addCartEvent_result:
20075 
 
20076 
  thrift_spec = (
20077 
  )
20078 
 
20079 
  def read(self, iprot):
20080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20082 
      return
20083 
    iprot.readStructBegin()
20084 
    while True:
20085 
      (fname, ftype, fid) = iprot.readFieldBegin()
20086 
      if ftype == TType.STOP:
20087 
        break
20088 
      else:
20089 
        iprot.skip(ftype)
20090 
      iprot.readFieldEnd()
20091 
    iprot.readStructEnd()
20092 
 
20093 
  def write(self, oprot):
20094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20096 
      return
20097 
    oprot.writeStructBegin('addCartEvent_result')
20098 
    oprot.writeFieldStop()
20099 
    oprot.writeStructEnd()
20100 
 
20101 
  def validate(self):
20102 
    return
20103 
 
20104 
 
20105 
  def __repr__(self):
20106 
    L = ['%s=%r' % (key, value)
20107 
      for key, value in self.__dict__.iteritems()]
20108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20109 
 
20110 
  def __eq__(self, other):
20111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20112 
 
20113 
  def __ne__(self, other):
20114 
    return not (self == other)
8139 kshitij.so 20115 
 
8182 amar.kumar 20116 
class addEbayItem_args:
20117 
  """
20118 
  Attributes:
20119 
   - ebayItem
20120 
  """
20121 
 
20122 
  thrift_spec = (
20123 
    None, # 0
20124 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20125 
  )
20126 
 
20127 
  def __init__(self, ebayItem=None,):
20128 
    self.ebayItem = ebayItem
20129 
 
20130 
  def read(self, iprot):
20131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20133 
      return
20134 
    iprot.readStructBegin()
20135 
    while True:
20136 
      (fname, ftype, fid) = iprot.readFieldBegin()
20137 
      if ftype == TType.STOP:
20138 
        break
20139 
      if fid == 1:
20140 
        if ftype == TType.STRUCT:
20141 
          self.ebayItem = EbayItem()
20142 
          self.ebayItem.read(iprot)
20143 
        else:
20144 
          iprot.skip(ftype)
20145 
      else:
20146 
        iprot.skip(ftype)
20147 
      iprot.readFieldEnd()
20148 
    iprot.readStructEnd()
20149 
 
20150 
  def write(self, oprot):
20151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20153 
      return
20154 
    oprot.writeStructBegin('addEbayItem_args')
20155 
    if self.ebayItem is not None:
20156 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20157 
      self.ebayItem.write(oprot)
20158 
      oprot.writeFieldEnd()
20159 
    oprot.writeFieldStop()
20160 
    oprot.writeStructEnd()
20161 
 
20162 
  def validate(self):
20163 
    return
20164 
 
20165 
 
20166 
  def __repr__(self):
20167 
    L = ['%s=%r' % (key, value)
20168 
      for key, value in self.__dict__.iteritems()]
20169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20170 
 
20171 
  def __eq__(self, other):
20172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20173 
 
20174 
  def __ne__(self, other):
20175 
    return not (self == other)
20176 
 
20177 
class addEbayItem_result:
20178 
 
20179 
  thrift_spec = (
20180 
  )
20181 
 
20182 
  def read(self, iprot):
20183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20185 
      return
20186 
    iprot.readStructBegin()
20187 
    while True:
20188 
      (fname, ftype, fid) = iprot.readFieldBegin()
20189 
      if ftype == TType.STOP:
20190 
        break
20191 
      else:
20192 
        iprot.skip(ftype)
20193 
      iprot.readFieldEnd()
20194 
    iprot.readStructEnd()
20195 
 
20196 
  def write(self, oprot):
20197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20199 
      return
20200 
    oprot.writeStructBegin('addEbayItem_result')
20201 
    oprot.writeFieldStop()
20202 
    oprot.writeStructEnd()
20203 
 
20204 
  def validate(self):
20205 
    return
20206 
 
20207 
 
20208 
  def __repr__(self):
20209 
    L = ['%s=%r' % (key, value)
20210 
      for key, value in self.__dict__.iteritems()]
20211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20212 
 
20213 
  def __eq__(self, other):
20214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20215 
 
20216 
  def __ne__(self, other):
20217 
    return not (self == other)
20218 
 
20219 
class getEbayItem_args:
20220 
  """
20221 
  Attributes:
20222 
   - listingId
20223 
  """
20224 
 
20225 
  thrift_spec = (
20226 
    None, # 0
20227 
    (1, TType.STRING, 'listingId', None, None, ), # 1
20228 
  )
20229 
 
20230 
  def __init__(self, listingId=None,):
20231 
    self.listingId = listingId
20232 
 
20233 
  def read(self, iprot):
20234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20236 
      return
20237 
    iprot.readStructBegin()
20238 
    while True:
20239 
      (fname, ftype, fid) = iprot.readFieldBegin()
20240 
      if ftype == TType.STOP:
20241 
        break
20242 
      if fid == 1:
20243 
        if ftype == TType.STRING:
20244 
          self.listingId = iprot.readString();
20245 
        else:
20246 
          iprot.skip(ftype)
20247 
      else:
20248 
        iprot.skip(ftype)
20249 
      iprot.readFieldEnd()
20250 
    iprot.readStructEnd()
20251 
 
20252 
  def write(self, oprot):
20253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20255 
      return
20256 
    oprot.writeStructBegin('getEbayItem_args')
20257 
    if self.listingId is not None:
20258 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
20259 
      oprot.writeString(self.listingId)
20260 
      oprot.writeFieldEnd()
20261 
    oprot.writeFieldStop()
20262 
    oprot.writeStructEnd()
20263 
 
20264 
  def validate(self):
20265 
    return
20266 
 
20267 
 
20268 
  def __repr__(self):
20269 
    L = ['%s=%r' % (key, value)
20270 
      for key, value in self.__dict__.iteritems()]
20271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20272 
 
20273 
  def __eq__(self, other):
20274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20275 
 
20276 
  def __ne__(self, other):
20277 
    return not (self == other)
20278 
 
20279 
class getEbayItem_result:
20280 
  """
20281 
  Attributes:
20282 
   - success
20283 
  """
20284 
 
20285 
  thrift_spec = (
20286 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
20287 
  )
20288 
 
20289 
  def __init__(self, success=None,):
20290 
    self.success = success
20291 
 
20292 
  def read(self, iprot):
20293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20295 
      return
20296 
    iprot.readStructBegin()
20297 
    while True:
20298 
      (fname, ftype, fid) = iprot.readFieldBegin()
20299 
      if ftype == TType.STOP:
20300 
        break
20301 
      if fid == 0:
20302 
        if ftype == TType.STRUCT:
20303 
          self.success = EbayItem()
20304 
          self.success.read(iprot)
20305 
        else:
20306 
          iprot.skip(ftype)
20307 
      else:
20308 
        iprot.skip(ftype)
20309 
      iprot.readFieldEnd()
20310 
    iprot.readStructEnd()
20311 
 
20312 
  def write(self, oprot):
20313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20315 
      return
20316 
    oprot.writeStructBegin('getEbayItem_result')
20317 
    if self.success is not None:
20318 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20319 
      self.success.write(oprot)
20320 
      oprot.writeFieldEnd()
20321 
    oprot.writeFieldStop()
20322 
    oprot.writeStructEnd()
20323 
 
20324 
  def validate(self):
20325 
    return
20326 
 
20327 
 
20328 
  def __repr__(self):
20329 
    L = ['%s=%r' % (key, value)
20330 
      for key, value in self.__dict__.iteritems()]
20331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20332 
 
20333 
  def __eq__(self, other):
20334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20335 
 
20336 
  def __ne__(self, other):
20337 
    return not (self == other)
20338 
 
20339 
class updateEbayItem_args:
20340 
  """
20341 
  Attributes:
20342 
   - ebayItem
20343 
  """
20344 
 
20345 
  thrift_spec = (
20346 
    None, # 0
20347 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20348 
  )
20349 
 
20350 
  def __init__(self, ebayItem=None,):
20351 
    self.ebayItem = ebayItem
20352 
 
20353 
  def read(self, iprot):
20354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20356 
      return
20357 
    iprot.readStructBegin()
20358 
    while True:
20359 
      (fname, ftype, fid) = iprot.readFieldBegin()
20360 
      if ftype == TType.STOP:
20361 
        break
20362 
      if fid == 1:
20363 
        if ftype == TType.STRUCT:
20364 
          self.ebayItem = EbayItem()
20365 
          self.ebayItem.read(iprot)
20366 
        else:
20367 
          iprot.skip(ftype)
20368 
      else:
20369 
        iprot.skip(ftype)
20370 
      iprot.readFieldEnd()
20371 
    iprot.readStructEnd()
20372 
 
20373 
  def write(self, oprot):
20374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20376 
      return
20377 
    oprot.writeStructBegin('updateEbayItem_args')
20378 
    if self.ebayItem is not None:
20379 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20380 
      self.ebayItem.write(oprot)
20381 
      oprot.writeFieldEnd()
20382 
    oprot.writeFieldStop()
20383 
    oprot.writeStructEnd()
20384 
 
20385 
  def validate(self):
20386 
    return
20387 
 
20388 
 
20389 
  def __repr__(self):
20390 
    L = ['%s=%r' % (key, value)
20391 
      for key, value in self.__dict__.iteritems()]
20392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20393 
 
20394 
  def __eq__(self, other):
20395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20396 
 
20397 
  def __ne__(self, other):
20398 
    return not (self == other)
20399 
 
20400 
class updateEbayItem_result:
20401 
 
20402 
  thrift_spec = (
20403 
  )
20404 
 
20405 
  def read(self, iprot):
20406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20408 
      return
20409 
    iprot.readStructBegin()
20410 
    while True:
20411 
      (fname, ftype, fid) = iprot.readFieldBegin()
20412 
      if ftype == TType.STOP:
20413 
        break
20414 
      else:
20415 
        iprot.skip(ftype)
20416 
      iprot.readFieldEnd()
20417 
    iprot.readStructEnd()
20418 
 
20419 
  def write(self, oprot):
20420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20422 
      return
20423 
    oprot.writeStructBegin('updateEbayItem_result')
20424 
    oprot.writeFieldStop()
20425 
    oprot.writeStructEnd()
20426 
 
20427 
  def validate(self):
20428 
    return
20429 
 
20430 
 
20431 
  def __repr__(self):
20432 
    L = ['%s=%r' % (key, value)
20433 
      for key, value in self.__dict__.iteritems()]
20434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20435 
 
20436 
  def __eq__(self, other):
20437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20438 
 
20439 
  def __ne__(self, other):
20440 
    return not (self == other)
20441 
 
8139 kshitij.so 20442 
class getAmazonListedItems_args:
20443 
  """
20444 
  Attributes:
20445 
   - offset
20446 
   - limit
20447 
  """
20448 
 
20449 
  thrift_spec = (
20450 
    None, # 0
20451 
    (1, TType.I64, 'offset', None, None, ), # 1
20452 
    (2, TType.I64, 'limit', None, None, ), # 2
20453 
  )
20454 
 
20455 
  def __init__(self, offset=None, limit=None,):
20456 
    self.offset = offset
20457 
    self.limit = limit
20458 
 
20459 
  def read(self, iprot):
20460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20462 
      return
20463 
    iprot.readStructBegin()
20464 
    while True:
20465 
      (fname, ftype, fid) = iprot.readFieldBegin()
20466 
      if ftype == TType.STOP:
20467 
        break
20468 
      if fid == 1:
20469 
        if ftype == TType.I64:
20470 
          self.offset = iprot.readI64();
20471 
        else:
20472 
          iprot.skip(ftype)
20473 
      elif fid == 2:
20474 
        if ftype == TType.I64:
20475 
          self.limit = iprot.readI64();
20476 
        else:
20477 
          iprot.skip(ftype)
20478 
      else:
20479 
        iprot.skip(ftype)
20480 
      iprot.readFieldEnd()
20481 
    iprot.readStructEnd()
20482 
 
20483 
  def write(self, oprot):
20484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20486 
      return
20487 
    oprot.writeStructBegin('getAmazonListedItems_args')
20488 
    if self.offset is not None:
20489 
      oprot.writeFieldBegin('offset', TType.I64, 1)
20490 
      oprot.writeI64(self.offset)
20491 
      oprot.writeFieldEnd()
20492 
    if self.limit is not None:
20493 
      oprot.writeFieldBegin('limit', TType.I64, 2)
20494 
      oprot.writeI64(self.limit)
20495 
      oprot.writeFieldEnd()
20496 
    oprot.writeFieldStop()
20497 
    oprot.writeStructEnd()
20498 
 
20499 
  def validate(self):
20500 
    return
20501 
 
20502 
 
20503 
  def __repr__(self):
20504 
    L = ['%s=%r' % (key, value)
20505 
      for key, value in self.__dict__.iteritems()]
20506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20507 
 
20508 
  def __eq__(self, other):
20509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20510 
 
20511 
  def __ne__(self, other):
20512 
    return not (self == other)
20513 
 
20514 
class getAmazonListedItems_result:
20515 
  """
20516 
  Attributes:
20517 
   - success
20518 
  """
20519 
 
20520 
  thrift_spec = (
20521 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20522 
  )
20523 
 
20524 
  def __init__(self, success=None,):
20525 
    self.success = success
20526 
 
20527 
  def read(self, iprot):
20528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20530 
      return
20531 
    iprot.readStructBegin()
20532 
    while True:
20533 
      (fname, ftype, fid) = iprot.readFieldBegin()
20534 
      if ftype == TType.STOP:
20535 
        break
20536 
      if fid == 0:
20537 
        if ftype == TType.LIST:
20538 
          self.success = []
8590 kshitij.so 20539 
          (_etype440, _size437) = iprot.readListBegin()
20540 
          for _i441 in xrange(_size437):
20541 
            _elem442 = Amazonlisted()
20542 
            _elem442.read(iprot)
20543 
            self.success.append(_elem442)
8139 kshitij.so 20544 
          iprot.readListEnd()
20545 
        else:
20546 
          iprot.skip(ftype)
20547 
      else:
20548 
        iprot.skip(ftype)
20549 
      iprot.readFieldEnd()
20550 
    iprot.readStructEnd()
20551 
 
20552 
  def write(self, oprot):
20553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20555 
      return
20556 
    oprot.writeStructBegin('getAmazonListedItems_result')
20557 
    if self.success is not None:
20558 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20559 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 20560 
      for iter443 in self.success:
20561 
        iter443.write(oprot)
8139 kshitij.so 20562 
      oprot.writeListEnd()
20563 
      oprot.writeFieldEnd()
20564 
    oprot.writeFieldStop()
20565 
    oprot.writeStructEnd()
20566 
 
20567 
  def validate(self):
20568 
    return
20569 
 
20570 
 
20571 
  def __repr__(self):
20572 
    L = ['%s=%r' % (key, value)
20573 
      for key, value in self.__dict__.iteritems()]
20574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20575 
 
20576 
  def __eq__(self, other):
20577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20578 
 
20579 
  def __ne__(self, other):
20580 
    return not (self == other)
8168 kshitij.so 20581 
 
20582 
class updateAmazonAttributesInBulk_args:
20583 
  """
20584 
  Attributes:
20585 
   - amazonlisted
20586 
  """
20587 
 
20588 
  thrift_spec = (
20589 
    None, # 0
20590 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
20591 
  )
20592 
 
20593 
  def __init__(self, amazonlisted=None,):
20594 
    self.amazonlisted = amazonlisted
20595 
 
20596 
  def read(self, iprot):
20597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20599 
      return
20600 
    iprot.readStructBegin()
20601 
    while True:
20602 
      (fname, ftype, fid) = iprot.readFieldBegin()
20603 
      if ftype == TType.STOP:
20604 
        break
20605 
      if fid == 1:
20606 
        if ftype == TType.MAP:
20607 
          self.amazonlisted = {}
8590 kshitij.so 20608 
          (_ktype445, _vtype446, _size444 ) = iprot.readMapBegin()
20609 
          for _i448 in xrange(_size444):
20610 
            _key449 = iprot.readI64();
20611 
            _val450 = Amazonlisted()
20612 
            _val450.read(iprot)
20613 
            self.amazonlisted[_key449] = _val450
8168 kshitij.so 20614 
          iprot.readMapEnd()
20615 
        else:
20616 
          iprot.skip(ftype)
20617 
      else:
20618 
        iprot.skip(ftype)
20619 
      iprot.readFieldEnd()
20620 
    iprot.readStructEnd()
20621 
 
20622 
  def write(self, oprot):
20623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20625 
      return
20626 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
20627 
    if self.amazonlisted is not None:
20628 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
20629 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
8590 kshitij.so 20630 
      for kiter451,viter452 in self.amazonlisted.items():
20631 
        oprot.writeI64(kiter451)
20632 
        viter452.write(oprot)
8168 kshitij.so 20633 
      oprot.writeMapEnd()
20634 
      oprot.writeFieldEnd()
20635 
    oprot.writeFieldStop()
20636 
    oprot.writeStructEnd()
20637 
 
20638 
  def validate(self):
20639 
    return
20640 
 
20641 
 
20642 
  def __repr__(self):
20643 
    L = ['%s=%r' % (key, value)
20644 
      for key, value in self.__dict__.iteritems()]
20645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20646 
 
20647 
  def __eq__(self, other):
20648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20649 
 
20650 
  def __ne__(self, other):
20651 
    return not (self == other)
20652 
 
20653 
class updateAmazonAttributesInBulk_result:
20654 
  """
20655 
  Attributes:
20656 
   - success
20657 
  """
20658 
 
20659 
  thrift_spec = (
20660 
    (0, TType.BOOL, 'success', None, None, ), # 0
20661 
  )
20662 
 
20663 
  def __init__(self, success=None,):
20664 
    self.success = success
20665 
 
20666 
  def read(self, iprot):
20667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20669 
      return
20670 
    iprot.readStructBegin()
20671 
    while True:
20672 
      (fname, ftype, fid) = iprot.readFieldBegin()
20673 
      if ftype == TType.STOP:
20674 
        break
20675 
      if fid == 0:
20676 
        if ftype == TType.BOOL:
20677 
          self.success = iprot.readBool();
20678 
        else:
20679 
          iprot.skip(ftype)
20680 
      else:
20681 
        iprot.skip(ftype)
20682 
      iprot.readFieldEnd()
20683 
    iprot.readStructEnd()
20684 
 
20685 
  def write(self, oprot):
20686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20688 
      return
20689 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
20690 
    if self.success is not None:
20691 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20692 
      oprot.writeBool(self.success)
20693 
      oprot.writeFieldEnd()
20694 
    oprot.writeFieldStop()
20695 
    oprot.writeStructEnd()
20696 
 
20697 
  def validate(self):
20698 
    return
20699 
 
20700 
 
20701 
  def __repr__(self):
20702 
    L = ['%s=%r' % (key, value)
20703 
      for key, value in self.__dict__.iteritems()]
20704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20705 
 
20706 
  def __eq__(self, other):
20707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20708 
 
20709 
  def __ne__(self, other):
20710 
    return not (self == other)
8379 vikram.rag 20711 
 
20712 
class getAllItemstoListOnFba_args:
20713 
 
20714 
  thrift_spec = (
20715 
  )
20716 
 
20717 
  def read(self, iprot):
20718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20720 
      return
20721 
    iprot.readStructBegin()
20722 
    while True:
20723 
      (fname, ftype, fid) = iprot.readFieldBegin()
20724 
      if ftype == TType.STOP:
20725 
        break
20726 
      else:
20727 
        iprot.skip(ftype)
20728 
      iprot.readFieldEnd()
20729 
    iprot.readStructEnd()
20730 
 
20731 
  def write(self, oprot):
20732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20734 
      return
20735 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
20736 
    oprot.writeFieldStop()
20737 
    oprot.writeStructEnd()
20738 
 
20739 
  def validate(self):
20740 
    return
20741 
 
20742 
 
20743 
  def __repr__(self):
20744 
    L = ['%s=%r' % (key, value)
20745 
      for key, value in self.__dict__.iteritems()]
20746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20747 
 
20748 
  def __eq__(self, other):
20749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20750 
 
20751 
  def __ne__(self, other):
20752 
    return not (self == other)
20753 
 
20754 
class getAllItemstoListOnFba_result:
20755 
  """
20756 
  Attributes:
20757 
   - success
20758 
  """
20759 
 
20760 
  thrift_spec = (
20761 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20762 
  )
20763 
 
20764 
  def __init__(self, success=None,):
20765 
    self.success = success
20766 
 
20767 
  def read(self, iprot):
20768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20770 
      return
20771 
    iprot.readStructBegin()
20772 
    while True:
20773 
      (fname, ftype, fid) = iprot.readFieldBegin()
20774 
      if ftype == TType.STOP:
20775 
        break
20776 
      if fid == 0:
20777 
        if ftype == TType.LIST:
20778 
          self.success = []
8590 kshitij.so 20779 
          (_etype456, _size453) = iprot.readListBegin()
20780 
          for _i457 in xrange(_size453):
20781 
            _elem458 = Amazonlisted()
20782 
            _elem458.read(iprot)
20783 
            self.success.append(_elem458)
8379 vikram.rag 20784 
          iprot.readListEnd()
20785 
        else:
20786 
          iprot.skip(ftype)
20787 
      else:
20788 
        iprot.skip(ftype)
20789 
      iprot.readFieldEnd()
20790 
    iprot.readStructEnd()
20791 
 
20792 
  def write(self, oprot):
20793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20795 
      return
20796 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
20797 
    if self.success is not None:
20798 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20799 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 20800 
      for iter459 in self.success:
20801 
        iter459.write(oprot)
8379 vikram.rag 20802 
      oprot.writeListEnd()
20803 
      oprot.writeFieldEnd()
20804 
    oprot.writeFieldStop()
20805 
    oprot.writeStructEnd()
20806 
 
20807 
  def validate(self):
20808 
    return
20809 
 
20810 
 
20811 
  def __repr__(self):
20812 
    L = ['%s=%r' % (key, value)
20813 
      for key, value in self.__dict__.iteritems()]
20814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20815 
 
20816 
  def __eq__(self, other):
20817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20818 
 
20819 
  def __ne__(self, other):
20820 
    return not (self == other)
20821 
 
20822 
class getAllItemstoListOnNonFba_args:
20823 
 
20824 
  thrift_spec = (
20825 
  )
20826 
 
20827 
  def read(self, iprot):
20828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20830 
      return
20831 
    iprot.readStructBegin()
20832 
    while True:
20833 
      (fname, ftype, fid) = iprot.readFieldBegin()
20834 
      if ftype == TType.STOP:
20835 
        break
20836 
      else:
20837 
        iprot.skip(ftype)
20838 
      iprot.readFieldEnd()
20839 
    iprot.readStructEnd()
20840 
 
20841 
  def write(self, oprot):
20842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20844 
      return
20845 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
20846 
    oprot.writeFieldStop()
20847 
    oprot.writeStructEnd()
20848 
 
20849 
  def validate(self):
20850 
    return
20851 
 
20852 
 
20853 
  def __repr__(self):
20854 
    L = ['%s=%r' % (key, value)
20855 
      for key, value in self.__dict__.iteritems()]
20856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20857 
 
20858 
  def __eq__(self, other):
20859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20860 
 
20861 
  def __ne__(self, other):
20862 
    return not (self == other)
20863 
 
20864 
class getAllItemstoListOnNonFba_result:
20865 
  """
20866 
  Attributes:
20867 
   - success
20868 
  """
20869 
 
20870 
  thrift_spec = (
20871 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20872 
  )
20873 
 
20874 
  def __init__(self, success=None,):
20875 
    self.success = success
20876 
 
20877 
  def read(self, iprot):
20878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20880 
      return
20881 
    iprot.readStructBegin()
20882 
    while True:
20883 
      (fname, ftype, fid) = iprot.readFieldBegin()
20884 
      if ftype == TType.STOP:
20885 
        break
20886 
      if fid == 0:
20887 
        if ftype == TType.LIST:
20888 
          self.success = []
8590 kshitij.so 20889 
          (_etype463, _size460) = iprot.readListBegin()
20890 
          for _i464 in xrange(_size460):
20891 
            _elem465 = Amazonlisted()
20892 
            _elem465.read(iprot)
20893 
            self.success.append(_elem465)
8379 vikram.rag 20894 
          iprot.readListEnd()
20895 
        else:
20896 
          iprot.skip(ftype)
20897 
      else:
20898 
        iprot.skip(ftype)
20899 
      iprot.readFieldEnd()
20900 
    iprot.readStructEnd()
20901 
 
20902 
  def write(self, oprot):
20903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20905 
      return
20906 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
20907 
    if self.success is not None:
20908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 20910 
      for iter466 in self.success:
20911 
        iter466.write(oprot)
8379 vikram.rag 20912 
      oprot.writeListEnd()
20913 
      oprot.writeFieldEnd()
20914 
    oprot.writeFieldStop()
20915 
    oprot.writeStructEnd()
20916 
 
20917 
  def validate(self):
20918 
    return
20919 
 
20920 
 
20921 
  def __repr__(self):
20922 
    L = ['%s=%r' % (key, value)
20923 
      for key, value in self.__dict__.iteritems()]
20924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20925 
 
20926 
  def __eq__(self, other):
20927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20928 
 
20929 
  def __ne__(self, other):
20930 
    return not (self == other)
8616 vikram.rag 20931 
 
20932 
class getAllSnapdealListedActiveItems_args:
20933 
 
20934 
  thrift_spec = (
20935 
  )
20936 
 
20937 
  def read(self, iprot):
20938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20940 
      return
20941 
    iprot.readStructBegin()
20942 
    while True:
20943 
      (fname, ftype, fid) = iprot.readFieldBegin()
20944 
      if ftype == TType.STOP:
20945 
        break
20946 
      else:
20947 
        iprot.skip(ftype)
20948 
      iprot.readFieldEnd()
20949 
    iprot.readStructEnd()
20950 
 
20951 
  def write(self, oprot):
20952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20954 
      return
20955 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_args')
20956 
    oprot.writeFieldStop()
20957 
    oprot.writeStructEnd()
20958 
 
20959 
  def validate(self):
20960 
    return
20961 
 
20962 
 
20963 
  def __repr__(self):
20964 
    L = ['%s=%r' % (key, value)
20965 
      for key, value in self.__dict__.iteritems()]
20966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20967 
 
20968 
  def __eq__(self, other):
20969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20970 
 
20971 
  def __ne__(self, other):
20972 
    return not (self == other)
20973 
 
20974 
class getAllSnapdealListedActiveItems_result:
20975 
  """
20976 
  Attributes:
20977 
   - success
20978 
  """
20979 
 
20980 
  thrift_spec = (
20981 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20982 
  )
20983 
 
20984 
  def __init__(self, success=None,):
20985 
    self.success = success
20986 
 
20987 
  def read(self, iprot):
20988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20990 
      return
20991 
    iprot.readStructBegin()
20992 
    while True:
20993 
      (fname, ftype, fid) = iprot.readFieldBegin()
20994 
      if ftype == TType.STOP:
20995 
        break
20996 
      if fid == 0:
20997 
        if ftype == TType.LIST:
20998 
          self.success = []
20999 
          (_etype470, _size467) = iprot.readListBegin()
21000 
          for _i471 in xrange(_size467):
21001 
            _elem472 = Item()
21002 
            _elem472.read(iprot)
21003 
            self.success.append(_elem472)
21004 
          iprot.readListEnd()
21005 
        else:
21006 
          iprot.skip(ftype)
21007 
      else:
21008 
        iprot.skip(ftype)
21009 
      iprot.readFieldEnd()
21010 
    iprot.readStructEnd()
21011 
 
21012 
  def write(self, oprot):
21013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21015 
      return
21016 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_result')
21017 
    if self.success is not None:
21018 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21019 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
21020 
      for iter473 in self.success:
21021 
        iter473.write(oprot)
21022 
      oprot.writeListEnd()
21023 
      oprot.writeFieldEnd()
21024 
    oprot.writeFieldStop()
21025 
    oprot.writeStructEnd()
21026 
 
21027 
  def validate(self):
21028 
    return
21029 
 
21030 
 
21031 
  def __repr__(self):
21032 
    L = ['%s=%r' % (key, value)
21033 
      for key, value in self.__dict__.iteritems()]
21034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21035 
 
21036 
  def __eq__(self, other):
21037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21038 
 
21039 
  def __ne__(self, other):
21040 
    return not (self == other)