Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
6850 kshitij.so 316 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
317 
    """
318 
    Parameters:
319 
     - bannerName
320 
     - imageName
321 
     - link
322 
     - priority
323 
     - isActive
324 
     - hasMap
325 
    """
326 
    pass
327 
 
328 
  def getAllBanners(self, ):
329 
    pass
330 
 
331 
  def deleteBanner(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getBannerDetails(self, bannerName):
339 
    """
340 
    Parameters:
341 
     - bannerName
342 
    """
343 
    pass
344 
 
345 
  def getActiveBanners(self, ):
346 
    pass
347 
 
6849 kshitij.so 348 
  def addBannerMap(self, bannerName, mapLink, coordinates):
349 
    """
350 
    Parameters:
351 
     - bannerName
352 
     - mapLink
353 
     - coordinates
354 
    """
355 
    pass
356 
 
357 
  def deleteBannerMap(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
364 
  def getBannerMapDetails(self, bannerName):
365 
    """
366 
    Parameters:
367 
     - bannerName
368 
    """
369 
    pass
370 
 
5944 mandeep.dh 371 
  def deleteSimilarItem(self, itemId, catalogItemId):
372 
    """
373 
    Delete similar item.
374 
 
375 
    Parameters:
376 
     - itemId
377 
     - catalogItemId
378 
    """
379 
    pass
380 
 
381 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
382 
    """
383 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
384 
    If yes, returns the itemId else returns 0
385 
 
386 
    Parameters:
387 
     - brand
388 
     - modelNumber
389 
     - modelName
390 
     - color
391 
    """
392 
    pass
393 
 
394 
  def validateRiskyStatus(self, itemId):
395 
    """
396 
    Check wether item is risky and change status if inventory is not available for risky items
397 
 
398 
    Parameters:
399 
     - itemId
400 
    """
401 
    pass
402 
 
403 
  def changeItemRiskyFlag(self, itemId, risky):
404 
    """
405 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
406 
 
407 
    Parameters:
408 
     - itemId
409 
     - risky
410 
    """
411 
    pass
412 
 
413 
  def getItemsByRiskyFlag(self, ):
414 
    """
415 
    Returns list of items marked as risky.
416 
    """
417 
    pass
418 
 
419 
  def getItemsForMasterSheet(self, category, brand):
420 
    """
421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
422 
 
423 
    Parameters:
424 
     - category
425 
     - brand
426 
    """
427 
    pass
428 
 
429 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
430 
    """
431 
    Returns list of catalog ids of items with same similarity index as of the given itemId
432 
 
433 
    Parameters:
434 
     - beginIndex
435 
     - totalItems
436 
     - itemId
437 
    """
438 
    pass
439 
 
440 
  def addProductNotification(self, itemId, email):
441 
    """
442 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
443 
 
444 
    Parameters:
445 
     - itemId
446 
     - email
447 
    """
448 
    pass
449 
 
450 
  def sendProductNotifications(self, ):
451 
    """
452 
    Send the product notifications to the users for items which has stock.
453 
    """
454 
    pass
455 
 
456 
  def getAllBrandsByCategory(self, categoryId):
457 
    """
458 
    Returns list of brand names for a given category Id
459 
 
460 
    Parameters:
461 
     - categoryId
462 
    """
463 
    pass
464 
 
465 
  def getAllBrands(self, ):
466 
    """
467 
    Returns list of brand names
468 
    """
469 
    pass
470 
 
471 
  def getAllSources(self, ):
472 
    """
473 
    Return list of all sources
474 
    """
475 
    pass
476 
 
477 
  def getItemPricingBySource(self, itemId, sourceId):
478 
    """
479 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
480 
 
481 
    Parameters:
482 
     - itemId
483 
     - sourceId
484 
    """
485 
    pass
486 
 
487 
  def addSourceItemPricing(self, sourceItemPricing):
488 
    """
489 
    Adds prices to be displayed corresponding to the item if user comes from a source.
490 
    If item is not found or source is not found, it will throw exception.
491 
 
492 
    Parameters:
493 
     - sourceItemPricing
494 
    """
495 
    pass
496 
 
497 
  def getAllSourcePricing(self, itemId):
498 
    """
499 
    Returns the list of source pricing information of an item.
500 
    Raises an exception if item not found corresponding to itemId
501 
 
502 
    Parameters:
503 
     - itemId
504 
    """
505 
    pass
506 
 
507 
  def getItemForSource(self, item_id, sourceId):
508 
    """
509 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
510 
 
511 
    Parameters:
512 
     - item_id
513 
     - sourceId
514 
    """
515 
    pass
516 
 
517 
  def searchItemsInRange(self, searchTerms, offset, limit):
518 
    """
519 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
520 
 
521 
    Parameters:
522 
     - searchTerms
523 
     - offset
524 
     - limit
525 
    """
526 
    pass
527 
 
528 
  def getSearchResultCount(self, searchTerms):
529 
    """
530 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
531 
 
532 
    Parameters:
533 
     - searchTerms
534 
    """
535 
    pass
536 
 
537 
  def getProductNotifications(self, startDateTime):
538 
    """
539 
    Returns a list of product notifications added after a supplied datetime
540 
 
541 
    Parameters:
542 
     - startDateTime
543 
    """
544 
    pass
545 
 
546 
  def getProductNotificationRequestCount(self, startDateTime):
547 
    """
548 
    Returns a list of count of requests for product notification against each item
549 
 
550 
    Parameters:
551 
     - startDateTime
552 
    """
553 
    pass
554 
 
555 
  def addAuthorizationLog(self, itemId, username, reason):
556 
    """
557 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
558 
 
559 
    Parameters:
560 
     - itemId
561 
     - username
562 
     - reason
563 
    """
564 
    pass
565 
 
566 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
567 
    """
568 
    Parameters:
569 
     - catalog_item_id
570 
     - voucherType
571 
     - voucherAmount
572 
    """
573 
    pass
574 
 
575 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
576 
    """
577 
    Parameters:
578 
     - catalog_item_id
579 
     - voucherType
580 
    """
581 
    pass
582 
 
583 
  def getVoucherAmount(self, itemId, voucherType):
584 
    """
585 
    Parameters:
586 
     - itemId
587 
     - voucherType
588 
    """
589 
    pass
590 
 
591 
  def getAllItemVouchers(self, itemId):
592 
    """
593 
    Parameters:
594 
     - itemId
595 
    """
596 
    pass
597 
 
598 
  def isValidCatalogItemId(self, catalog_item_id):
599 
    """
600 
    Parameters:
601 
     - catalog_item_id
602 
    """
603 
    pass
604 
 
7330 amit.gupta 605 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 606 
    """
607 
    Parameters:
608 
     - itemId
7330 amit.gupta 609 
     - stateId
6039 amit.gupta 610 
     - price
611 
    """
612 
    pass
5944 mandeep.dh 613 
 
6039 amit.gupta 614 
  def getVatAmountForItem(self, itemId, price):
615 
    """
616 
    Parameters:
617 
     - itemId
618 
     - price
619 
    """
620 
    pass
621 
 
6531 vikram.rag 622 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
623 
    """
624 
    Parameters:
625 
     - offset
626 
     - limit
627 
    """
628 
    pass
6039 amit.gupta 629 
 
6821 amar.kumar 630 
  def getAllAliveItems(self, ):
631 
    pass
632 
 
6921 anupam.sin 633 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 634 
    """
635 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 636 
 
6805 anupam.sin 637 
    Parameters:
638 
     - itemId
6921 anupam.sin 639 
     - price
6805 anupam.sin 640 
     - insurerId
641 
     - quantity
642 
    """
643 
    pass
644 
 
645 
  def getInsurer(self, insurerId):
646 
    """
647 
    Parameters:
648 
     - insurerId
649 
    """
650 
    pass
651 
 
6838 vikram.rag 652 
  def getAllInsurers(self, ):
653 
    pass
6805 anupam.sin 654 
 
6962 rajveer 655 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
656 
    """
657 
    Parameters:
658 
     - insurerId
659 
     - amount
660 
    """
661 
    pass
6838 vikram.rag 662 
 
7190 amar.kumar 663 
  def getFreebieForItem(self, itemId):
664 
    """
665 
    Parameters:
666 
     - itemId
667 
    """
668 
    pass
6962 rajveer 669 
 
7190 amar.kumar 670 
  def addOrUpdateFreebieForItem(self, freebieItem):
671 
    """
672 
    Parameters:
673 
     - freebieItem
674 
    """
675 
    pass
676 
 
7272 amit.gupta 677 
  def addOrUpdateBrandInfo(self, brandInfo):
678 
    """
679 
    Parameters:
680 
     - brandInfo
681 
    """
682 
    pass
683 
 
684 
  def getBrandInfo(self, ):
685 
    pass
686 
 
7256 rajveer 687 
  def getStorePricing(self, itemId):
688 
    """
689 
    Parameters:
690 
     - itemId
691 
    """
692 
    pass
7190 amar.kumar 693 
 
7306 rajveer 694 
  def getStorePricings(self, itemIds):
695 
    """
696 
    Parameters:
697 
     - itemIds
698 
    """
699 
    pass
700 
 
7382 rajveer 701 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 702 
    """
703 
    Parameters:
704 
     - sp
7382 rajveer 705 
     - allColors
7265 rajveer 706 
    """
707 
    pass
7256 rajveer 708 
 
7281 kshitij.so 709 
  def getAllAmazonListedItems(self, ):
710 
    pass
7265 rajveer 711 
 
7281 kshitij.so 712 
  def getAmazonItemDetails(self, itemId):
713 
    """
714 
    Parameters:
715 
     - itemId
716 
    """
717 
    pass
718 
 
7367 kshitij.so 719 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 720 
    """
721 
    Parameters:
722 
     - itemId
723 
     - fbaPrice
724 
     - sellingPrice
725 
     - isFba
726 
     - isNonFba
727 
     - isInventoryOverride
7367 kshitij.so 728 
     - handlingTime
729 
     - isCustomTime
7281 kshitij.so 730 
    """
731 
    pass
732 
 
733 
  def addAmazonItem(self, amazonlisted):
734 
    """
735 
    Parameters:
736 
     - amazonlisted
737 
    """
738 
    pass
739 
 
7291 vikram.rag 740 
  def getAsinItems(self, ):
741 
    pass
7281 kshitij.so 742 
 
7291 vikram.rag 743 
  def getAllFbaListedItems(self, ):
744 
    pass
745 
 
746 
  def getAllNonFbaListedItems(self, ):
747 
    pass
748 
 
7460 kshitij.so 749 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
750 
    """
751 
    Parameters:
752 
     - itemId
753 
     - holdInventory
754 
     - defaultInventory
755 
    """
756 
    pass
7291 vikram.rag 757 
 
7770 kshitij.so 758 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
759 
    """
760 
    Parameters:
761 
     - type
762 
     - sku
763 
     - timestamp
764 
    """
765 
    pass
7460 kshitij.so 766 
 
7770 kshitij.so 767 
 
5944 mandeep.dh 768 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
769 
  def __init__(self, iprot, oprot=None):
770 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
771 
 
772 
  def addItem(self, item):
773 
    """
774 
    Availability and inventory attributes
775 
 
776 
    Parameters:
777 
     - item
778 
    """
779 
    self.send_addItem(item)
780 
    return self.recv_addItem()
781 
 
782 
  def send_addItem(self, item):
783 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
784 
    args = addItem_args()
785 
    args.item = item
786 
    args.write(self._oprot)
787 
    self._oprot.writeMessageEnd()
788 
    self._oprot.trans.flush()
789 
 
790 
  def recv_addItem(self, ):
791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
792 
    if mtype == TMessageType.EXCEPTION:
793 
      x = TApplicationException()
794 
      x.read(self._iprot)
795 
      self._iprot.readMessageEnd()
796 
      raise x
797 
    result = addItem_result()
798 
    result.read(self._iprot)
799 
    self._iprot.readMessageEnd()
800 
    if result.success is not None:
801 
      return result.success
802 
    if result.cex is not None:
803 
      raise result.cex
804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
805 
 
806 
  def updateItem(self, item):
807 
    """
808 
    Parameters:
809 
     - item
810 
    """
811 
    self.send_updateItem(item)
812 
    return self.recv_updateItem()
813 
 
814 
  def send_updateItem(self, item):
815 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
816 
    args = updateItem_args()
817 
    args.item = item
818 
    args.write(self._oprot)
819 
    self._oprot.writeMessageEnd()
820 
    self._oprot.trans.flush()
821 
 
822 
  def recv_updateItem(self, ):
823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
824 
    if mtype == TMessageType.EXCEPTION:
825 
      x = TApplicationException()
826 
      x.read(self._iprot)
827 
      self._iprot.readMessageEnd()
828 
      raise x
829 
    result = updateItem_result()
830 
    result.read(self._iprot)
831 
    self._iprot.readMessageEnd()
832 
    if result.success is not None:
833 
      return result.success
834 
    if result.cex is not None:
835 
      raise result.cex
836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
837 
 
838 
  def isActive(self, itemId):
839 
    """
840 
    Checks if the item given to the corresponding itemId is active. If it's active,
841 
    whether it's risky and if it's risky, its inventory position.
842 
 
843 
    Parameters:
844 
     - itemId
845 
    """
846 
    self.send_isActive(itemId)
847 
    return self.recv_isActive()
848 
 
849 
  def send_isActive(self, itemId):
850 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
851 
    args = isActive_args()
852 
    args.itemId = itemId
853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
857 
  def recv_isActive(self, ):
858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
864 
    result = isActive_result()
865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
867 
    if result.success is not None:
868 
      return result.success
869 
    if result.isex is not None:
870 
      raise result.isex
871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
872 
 
7438 amit.gupta 873 
  def getItemsStatus(self, itemIds):
874 
    """
875 
    Parameters:
876 
     - itemIds
877 
    """
878 
    self.send_getItemsStatus(itemIds)
879 
    return self.recv_getItemsStatus()
880 
 
881 
  def send_getItemsStatus(self, itemIds):
882 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
883 
    args = getItemsStatus_args()
884 
    args.itemIds = itemIds
885 
    args.write(self._oprot)
886 
    self._oprot.writeMessageEnd()
887 
    self._oprot.trans.flush()
888 
 
889 
  def recv_getItemsStatus(self, ):
890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
891 
    if mtype == TMessageType.EXCEPTION:
892 
      x = TApplicationException()
893 
      x.read(self._iprot)
894 
      self._iprot.readMessageEnd()
895 
      raise x
896 
    result = getItemsStatus_result()
897 
    result.read(self._iprot)
898 
    self._iprot.readMessageEnd()
899 
    if result.success is not None:
900 
      return result.success
901 
    if result.isex is not None:
902 
      raise result.isex
903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
904 
 
5944 mandeep.dh 905 
  def getItemStatusDescription(self, itemId):
906 
    """
907 
    Parameters:
908 
     - itemId
909 
    """
910 
    self.send_getItemStatusDescription(itemId)
911 
    return self.recv_getItemStatusDescription()
912 
 
913 
  def send_getItemStatusDescription(self, itemId):
914 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
915 
    args = getItemStatusDescription_args()
916 
    args.itemId = itemId
917 
    args.write(self._oprot)
918 
    self._oprot.writeMessageEnd()
919 
    self._oprot.trans.flush()
920 
 
921 
  def recv_getItemStatusDescription(self, ):
922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
923 
    if mtype == TMessageType.EXCEPTION:
924 
      x = TApplicationException()
925 
      x.read(self._iprot)
926 
      self._iprot.readMessageEnd()
927 
      raise x
928 
    result = getItemStatusDescription_result()
929 
    result.read(self._iprot)
930 
    self._iprot.readMessageEnd()
931 
    if result.success is not None:
932 
      return result.success
933 
    if result.isex is not None:
934 
      raise result.isex
935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
936 
 
937 
  def startItemOn(self, item_id, timestamp):
938 
    """
939 
    Parameters:
940 
     - item_id
941 
     - timestamp
942 
    """
943 
    self.send_startItemOn(item_id, timestamp)
944 
    self.recv_startItemOn()
945 
 
946 
  def send_startItemOn(self, item_id, timestamp):
947 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
948 
    args = startItemOn_args()
949 
    args.item_id = item_id
950 
    args.timestamp = timestamp
951 
    args.write(self._oprot)
952 
    self._oprot.writeMessageEnd()
953 
    self._oprot.trans.flush()
954 
 
955 
  def recv_startItemOn(self, ):
956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
957 
    if mtype == TMessageType.EXCEPTION:
958 
      x = TApplicationException()
959 
      x.read(self._iprot)
960 
      self._iprot.readMessageEnd()
961 
      raise x
962 
    result = startItemOn_result()
963 
    result.read(self._iprot)
964 
    self._iprot.readMessageEnd()
965 
    if result.cex is not None:
966 
      raise result.cex
967 
    return
968 
 
969 
  def retireItemOn(self, item_id, timestamp):
970 
    """
971 
    Parameters:
972 
     - item_id
973 
     - timestamp
974 
    """
975 
    self.send_retireItemOn(item_id, timestamp)
976 
    self.recv_retireItemOn()
977 
 
978 
  def send_retireItemOn(self, item_id, timestamp):
979 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
980 
    args = retireItemOn_args()
981 
    args.item_id = item_id
982 
    args.timestamp = timestamp
983 
    args.write(self._oprot)
984 
    self._oprot.writeMessageEnd()
985 
    self._oprot.trans.flush()
986 
 
987 
  def recv_retireItemOn(self, ):
988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
989 
    if mtype == TMessageType.EXCEPTION:
990 
      x = TApplicationException()
991 
      x.read(self._iprot)
992 
      self._iprot.readMessageEnd()
993 
      raise x
994 
    result = retireItemOn_result()
995 
    result.read(self._iprot)
996 
    self._iprot.readMessageEnd()
997 
    if result.cex is not None:
998 
      raise result.cex
999 
    return
1000 
 
1001 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1002 
    """
1003 
    Parameters:
1004 
     - item_id
1005 
     - timestamp
1006 
     - newstatus
1007 
    """
1008 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1009 
    self.recv_changeItemStatus()
1010 
 
1011 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1012 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1013 
    args = changeItemStatus_args()
1014 
    args.item_id = item_id
1015 
    args.timestamp = timestamp
1016 
    args.newstatus = newstatus
1017 
    args.write(self._oprot)
1018 
    self._oprot.writeMessageEnd()
1019 
    self._oprot.trans.flush()
1020 
 
1021 
  def recv_changeItemStatus(self, ):
1022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1023 
    if mtype == TMessageType.EXCEPTION:
1024 
      x = TApplicationException()
1025 
      x.read(self._iprot)
1026 
      self._iprot.readMessageEnd()
1027 
      raise x
1028 
    result = changeItemStatus_result()
1029 
    result.read(self._iprot)
1030 
    self._iprot.readMessageEnd()
1031 
    if result.cex is not None:
1032 
      raise result.cex
1033 
    return
1034 
 
1035 
  def getItem(self, item_id):
1036 
    """
1037 
    Parameters:
1038 
     - item_id
1039 
    """
1040 
    self.send_getItem(item_id)
1041 
    return self.recv_getItem()
1042 
 
1043 
  def send_getItem(self, item_id):
1044 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1045 
    args = getItem_args()
1046 
    args.item_id = item_id
1047 
    args.write(self._oprot)
1048 
    self._oprot.writeMessageEnd()
1049 
    self._oprot.trans.flush()
1050 
 
1051 
  def recv_getItem(self, ):
1052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1053 
    if mtype == TMessageType.EXCEPTION:
1054 
      x = TApplicationException()
1055 
      x.read(self._iprot)
1056 
      self._iprot.readMessageEnd()
1057 
      raise x
1058 
    result = getItem_result()
1059 
    result.read(self._iprot)
1060 
    self._iprot.readMessageEnd()
1061 
    if result.success is not None:
1062 
      return result.success
1063 
    if result.cex is not None:
1064 
      raise result.cex
1065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1066 
 
1067 
  def getItemsByCatalogId(self, catalog_item_id):
1068 
    """
1069 
    Parameters:
1070 
     - catalog_item_id
1071 
    """
1072 
    self.send_getItemsByCatalogId(catalog_item_id)
1073 
    return self.recv_getItemsByCatalogId()
1074 
 
1075 
  def send_getItemsByCatalogId(self, catalog_item_id):
1076 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1077 
    args = getItemsByCatalogId_args()
1078 
    args.catalog_item_id = catalog_item_id
1079 
    args.write(self._oprot)
1080 
    self._oprot.writeMessageEnd()
1081 
    self._oprot.trans.flush()
1082 
 
1083 
  def recv_getItemsByCatalogId(self, ):
1084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1085 
    if mtype == TMessageType.EXCEPTION:
1086 
      x = TApplicationException()
1087 
      x.read(self._iprot)
1088 
      self._iprot.readMessageEnd()
1089 
      raise x
1090 
    result = getItemsByCatalogId_result()
1091 
    result.read(self._iprot)
1092 
    self._iprot.readMessageEnd()
1093 
    if result.success is not None:
1094 
      return result.success
1095 
    if result.cex is not None:
1096 
      raise result.cex
1097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1098 
 
1099 
  def getValidItemsByCatalogId(self, catalog_item_id):
1100 
    """
1101 
    Parameters:
1102 
     - catalog_item_id
1103 
    """
1104 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1105 
    return self.recv_getValidItemsByCatalogId()
1106 
 
1107 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1108 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1109 
    args = getValidItemsByCatalogId_args()
1110 
    args.catalog_item_id = catalog_item_id
1111 
    args.write(self._oprot)
1112 
    self._oprot.writeMessageEnd()
1113 
    self._oprot.trans.flush()
1114 
 
1115 
  def recv_getValidItemsByCatalogId(self, ):
1116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1117 
    if mtype == TMessageType.EXCEPTION:
1118 
      x = TApplicationException()
1119 
      x.read(self._iprot)
1120 
      self._iprot.readMessageEnd()
1121 
      raise x
1122 
    result = getValidItemsByCatalogId_result()
1123 
    result.read(self._iprot)
1124 
    self._iprot.readMessageEnd()
1125 
    if result.success is not None:
1126 
      return result.success
1127 
    if result.cex is not None:
1128 
      raise result.cex
1129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1130 
 
1131 
  def getAllItems(self, isActive):
1132 
    """
1133 
    Parameters:
1134 
     - isActive
1135 
    """
1136 
    self.send_getAllItems(isActive)
1137 
    return self.recv_getAllItems()
1138 
 
1139 
  def send_getAllItems(self, isActive):
1140 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1141 
    args = getAllItems_args()
1142 
    args.isActive = isActive
1143 
    args.write(self._oprot)
1144 
    self._oprot.writeMessageEnd()
1145 
    self._oprot.trans.flush()
1146 
 
1147 
  def recv_getAllItems(self, ):
1148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1149 
    if mtype == TMessageType.EXCEPTION:
1150 
      x = TApplicationException()
1151 
      x.read(self._iprot)
1152 
      self._iprot.readMessageEnd()
1153 
      raise x
1154 
    result = getAllItems_result()
1155 
    result.read(self._iprot)
1156 
    self._iprot.readMessageEnd()
1157 
    if result.success is not None:
1158 
      return result.success
1159 
    if result.cex is not None:
1160 
      raise result.cex
1161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1162 
 
1163 
  def getAllItemsByStatus(self, itemStatus):
1164 
    """
1165 
    Parameters:
1166 
     - itemStatus
1167 
    """
1168 
    self.send_getAllItemsByStatus(itemStatus)
1169 
    return self.recv_getAllItemsByStatus()
1170 
 
1171 
  def send_getAllItemsByStatus(self, itemStatus):
1172 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1173 
    args = getAllItemsByStatus_args()
1174 
    args.itemStatus = itemStatus
1175 
    args.write(self._oprot)
1176 
    self._oprot.writeMessageEnd()
1177 
    self._oprot.trans.flush()
1178 
 
1179 
  def recv_getAllItemsByStatus(self, ):
1180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1181 
    if mtype == TMessageType.EXCEPTION:
1182 
      x = TApplicationException()
1183 
      x.read(self._iprot)
1184 
      self._iprot.readMessageEnd()
1185 
      raise x
1186 
    result = getAllItemsByStatus_result()
1187 
    result.read(self._iprot)
1188 
    self._iprot.readMessageEnd()
1189 
    if result.success is not None:
1190 
      return result.success
1191 
    if result.cex is not None:
1192 
      raise result.cex
1193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1194 
 
1195 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1196 
    """
1197 
    Parameters:
1198 
     - entityId
1199 
     - category
1200 
     - brand
1201 
     - modelName
1202 
     - modelNumber
1203 
    """
1204 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1205 
    return self.recv_markItemAsContentComplete()
1206 
 
1207 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1208 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1209 
    args = markItemAsContentComplete_args()
1210 
    args.entityId = entityId
1211 
    args.category = category
1212 
    args.brand = brand
1213 
    args.modelName = modelName
1214 
    args.modelNumber = modelNumber
1215 
    args.write(self._oprot)
1216 
    self._oprot.writeMessageEnd()
1217 
    self._oprot.trans.flush()
1218 
 
1219 
  def recv_markItemAsContentComplete(self, ):
1220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1221 
    if mtype == TMessageType.EXCEPTION:
1222 
      x = TApplicationException()
1223 
      x.read(self._iprot)
1224 
      self._iprot.readMessageEnd()
1225 
      raise x
1226 
    result = markItemAsContentComplete_result()
1227 
    result.read(self._iprot)
1228 
    self._iprot.readMessageEnd()
1229 
    if result.success is not None:
1230 
      return result.success
1231 
    if result.cex is not None:
1232 
      raise result.cex
1233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1234 
 
1235 
  def getAllItemsInRange(self, offset, limit):
1236 
    """
1237 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1238 
 
1239 
    Parameters:
1240 
     - offset
1241 
     - limit
1242 
    """
1243 
    self.send_getAllItemsInRange(offset, limit)
1244 
    return self.recv_getAllItemsInRange()
1245 
 
1246 
  def send_getAllItemsInRange(self, offset, limit):
1247 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1248 
    args = getAllItemsInRange_args()
1249 
    args.offset = offset
1250 
    args.limit = limit
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_getAllItemsInRange(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = getAllItemsInRange_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
1265 
    if result.success is not None:
1266 
      return result.success
1267 
    if result.cex is not None:
1268 
      raise result.cex
1269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1270 
 
1271 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1272 
    """
1273 
    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.
1274 
 
1275 
    Parameters:
1276 
     - itemStatus
1277 
     - offset
1278 
     - limit
1279 
    """
1280 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1281 
    return self.recv_getAllItemsByStatusInRange()
1282 
 
1283 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1284 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1285 
    args = getAllItemsByStatusInRange_args()
1286 
    args.itemStatus = itemStatus
1287 
    args.offset = offset
1288 
    args.limit = limit
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getAllItemsByStatusInRange(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getAllItemsByStatusInRange_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
1303 
    if result.success is not None:
1304 
      return result.success
1305 
    if result.cex is not None:
1306 
      raise result.cex
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1308 
 
1309 
  def getItemCountByStatus(self, useStatus, itemStatus):
1310 
    """
1311 
    Gets a count of all items by status
1312 
 
1313 
    Parameters:
1314 
     - useStatus
1315 
     - itemStatus
1316 
    """
1317 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1318 
    return self.recv_getItemCountByStatus()
1319 
 
1320 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1321 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1322 
    args = getItemCountByStatus_args()
1323 
    args.useStatus = useStatus
1324 
    args.itemStatus = itemStatus
1325 
    args.write(self._oprot)
1326 
    self._oprot.writeMessageEnd()
1327 
    self._oprot.trans.flush()
1328 
 
1329 
  def recv_getItemCountByStatus(self, ):
1330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1331 
    if mtype == TMessageType.EXCEPTION:
1332 
      x = TApplicationException()
1333 
      x.read(self._iprot)
1334 
      self._iprot.readMessageEnd()
1335 
      raise x
1336 
    result = getItemCountByStatus_result()
1337 
    result.read(self._iprot)
1338 
    self._iprot.readMessageEnd()
1339 
    if result.success is not None:
1340 
      return result.success
1341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1342 
 
1343 
  def getBestSellers(self, ):
1344 
    self.send_getBestSellers()
1345 
    return self.recv_getBestSellers()
1346 
 
1347 
  def send_getBestSellers(self, ):
1348 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1349 
    args = getBestSellers_args()
1350 
    args.write(self._oprot)
1351 
    self._oprot.writeMessageEnd()
1352 
    self._oprot.trans.flush()
1353 
 
1354 
  def recv_getBestSellers(self, ):
1355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1356 
    if mtype == TMessageType.EXCEPTION:
1357 
      x = TApplicationException()
1358 
      x.read(self._iprot)
1359 
      self._iprot.readMessageEnd()
1360 
      raise x
1361 
    result = getBestSellers_result()
1362 
    result.read(self._iprot)
1363 
    self._iprot.readMessageEnd()
1364 
    if result.success is not None:
1365 
      return result.success
1366 
    if result.isex is not None:
1367 
      raise result.isex
1368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1369 
 
1370 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1371 
    """
1372 
    Parameters:
1373 
     - beginIndex
1374 
     - totalItems
1375 
     - brand
1376 
     - category
1377 
    """
1378 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1379 
    return self.recv_getBestSellersCatalogIds()
1380 
 
1381 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1382 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1383 
    args = getBestSellersCatalogIds_args()
1384 
    args.beginIndex = beginIndex
1385 
    args.totalItems = totalItems
1386 
    args.brand = brand
1387 
    args.category = category
1388 
    args.write(self._oprot)
1389 
    self._oprot.writeMessageEnd()
1390 
    self._oprot.trans.flush()
1391 
 
1392 
  def recv_getBestSellersCatalogIds(self, ):
1393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1394 
    if mtype == TMessageType.EXCEPTION:
1395 
      x = TApplicationException()
1396 
      x.read(self._iprot)
1397 
      self._iprot.readMessageEnd()
1398 
      raise x
1399 
    result = getBestSellersCatalogIds_result()
1400 
    result.read(self._iprot)
1401 
    self._iprot.readMessageEnd()
1402 
    if result.success is not None:
1403 
      return result.success
1404 
    if result.cex is not None:
1405 
      raise result.cex
1406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1407 
 
1408 
  def getBestSellersCount(self, ):
1409 
    self.send_getBestSellersCount()
1410 
    return self.recv_getBestSellersCount()
1411 
 
1412 
  def send_getBestSellersCount(self, ):
1413 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1414 
    args = getBestSellersCount_args()
1415 
    args.write(self._oprot)
1416 
    self._oprot.writeMessageEnd()
1417 
    self._oprot.trans.flush()
1418 
 
1419 
  def recv_getBestSellersCount(self, ):
1420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1421 
    if mtype == TMessageType.EXCEPTION:
1422 
      x = TApplicationException()
1423 
      x.read(self._iprot)
1424 
      self._iprot.readMessageEnd()
1425 
      raise x
1426 
    result = getBestSellersCount_result()
1427 
    result.read(self._iprot)
1428 
    self._iprot.readMessageEnd()
1429 
    if result.success is not None:
1430 
      return result.success
1431 
    if result.cex is not None:
1432 
      raise result.cex
1433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1434 
 
1435 
  def getBestDeals(self, ):
1436 
    self.send_getBestDeals()
1437 
    return self.recv_getBestDeals()
1438 
 
1439 
  def send_getBestDeals(self, ):
1440 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1441 
    args = getBestDeals_args()
1442 
    args.write(self._oprot)
1443 
    self._oprot.writeMessageEnd()
1444 
    self._oprot.trans.flush()
1445 
 
1446 
  def recv_getBestDeals(self, ):
1447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1448 
    if mtype == TMessageType.EXCEPTION:
1449 
      x = TApplicationException()
1450 
      x.read(self._iprot)
1451 
      self._iprot.readMessageEnd()
1452 
      raise x
1453 
    result = getBestDeals_result()
1454 
    result.read(self._iprot)
1455 
    self._iprot.readMessageEnd()
1456 
    if result.success is not None:
1457 
      return result.success
1458 
    if result.isex is not None:
1459 
      raise result.isex
1460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1461 
 
1462 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1463 
    """
1464 
    Parameters:
1465 
     - beginIndex
1466 
     - totalItems
1467 
     - brand
1468 
     - category
1469 
    """
1470 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1471 
    return self.recv_getBestDealsCatalogIds()
1472 
 
1473 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1474 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1475 
    args = getBestDealsCatalogIds_args()
1476 
    args.beginIndex = beginIndex
1477 
    args.totalItems = totalItems
1478 
    args.brand = brand
1479 
    args.category = category
1480 
    args.write(self._oprot)
1481 
    self._oprot.writeMessageEnd()
1482 
    self._oprot.trans.flush()
1483 
 
1484 
  def recv_getBestDealsCatalogIds(self, ):
1485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1486 
    if mtype == TMessageType.EXCEPTION:
1487 
      x = TApplicationException()
1488 
      x.read(self._iprot)
1489 
      self._iprot.readMessageEnd()
1490 
      raise x
1491 
    result = getBestDealsCatalogIds_result()
1492 
    result.read(self._iprot)
1493 
    self._iprot.readMessageEnd()
1494 
    if result.success is not None:
1495 
      return result.success
1496 
    if result.cex is not None:
1497 
      raise result.cex
1498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1499 
 
1500 
  def getBestDealsCount(self, ):
1501 
    self.send_getBestDealsCount()
1502 
    return self.recv_getBestDealsCount()
1503 
 
1504 
  def send_getBestDealsCount(self, ):
1505 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1506 
    args = getBestDealsCount_args()
1507 
    args.write(self._oprot)
1508 
    self._oprot.writeMessageEnd()
1509 
    self._oprot.trans.flush()
1510 
 
1511 
  def recv_getBestDealsCount(self, ):
1512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1513 
    if mtype == TMessageType.EXCEPTION:
1514 
      x = TApplicationException()
1515 
      x.read(self._iprot)
1516 
      self._iprot.readMessageEnd()
1517 
      raise x
1518 
    result = getBestDealsCount_result()
1519 
    result.read(self._iprot)
1520 
    self._iprot.readMessageEnd()
1521 
    if result.success is not None:
1522 
      return result.success
1523 
    if result.cex is not None:
1524 
      raise result.cex
1525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1526 
 
1527 
  def getComingSoon(self, ):
1528 
    self.send_getComingSoon()
1529 
    return self.recv_getComingSoon()
1530 
 
1531 
  def send_getComingSoon(self, ):
1532 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1533 
    args = getComingSoon_args()
1534 
    args.write(self._oprot)
1535 
    self._oprot.writeMessageEnd()
1536 
    self._oprot.trans.flush()
1537 
 
1538 
  def recv_getComingSoon(self, ):
1539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1540 
    if mtype == TMessageType.EXCEPTION:
1541 
      x = TApplicationException()
1542 
      x.read(self._iprot)
1543 
      self._iprot.readMessageEnd()
1544 
      raise x
1545 
    result = getComingSoon_result()
1546 
    result.read(self._iprot)
1547 
    self._iprot.readMessageEnd()
1548 
    if result.success is not None:
1549 
      return result.success
1550 
    if result.isex is not None:
1551 
      raise result.isex
1552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1553 
 
1554 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1555 
    """
1556 
    Parameters:
1557 
     - beginIndex
1558 
     - totalItems
1559 
     - brand
1560 
     - category
1561 
    """
1562 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1563 
    return self.recv_getComingSoonCatalogIds()
1564 
 
1565 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1566 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1567 
    args = getComingSoonCatalogIds_args()
1568 
    args.beginIndex = beginIndex
1569 
    args.totalItems = totalItems
1570 
    args.brand = brand
1571 
    args.category = category
1572 
    args.write(self._oprot)
1573 
    self._oprot.writeMessageEnd()
1574 
    self._oprot.trans.flush()
1575 
 
1576 
  def recv_getComingSoonCatalogIds(self, ):
1577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1578 
    if mtype == TMessageType.EXCEPTION:
1579 
      x = TApplicationException()
1580 
      x.read(self._iprot)
1581 
      self._iprot.readMessageEnd()
1582 
      raise x
1583 
    result = getComingSoonCatalogIds_result()
1584 
    result.read(self._iprot)
1585 
    self._iprot.readMessageEnd()
1586 
    if result.success is not None:
1587 
      return result.success
1588 
    if result.cex is not None:
1589 
      raise result.cex
1590 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1591 
 
1592 
  def getComingSoonCount(self, ):
1593 
    self.send_getComingSoonCount()
1594 
    return self.recv_getComingSoonCount()
1595 
 
1596 
  def send_getComingSoonCount(self, ):
1597 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1598 
    args = getComingSoonCount_args()
1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_getComingSoonCount(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = getComingSoonCount_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
1613 
    if result.success is not None:
1614 
      return result.success
1615 
    if result.cex is not None:
1616 
      raise result.cex
1617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1618 
 
1619 
  def getLatestArrivals(self, ):
1620 
    """
1621 
    Returns a list of items sorted in the descending order by start date.
1622 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1623 
    """
1624 
    self.send_getLatestArrivals()
1625 
    return self.recv_getLatestArrivals()
1626 
 
1627 
  def send_getLatestArrivals(self, ):
1628 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1629 
    args = getLatestArrivals_args()
1630 
    args.write(self._oprot)
1631 
    self._oprot.writeMessageEnd()
1632 
    self._oprot.trans.flush()
1633 
 
1634 
  def recv_getLatestArrivals(self, ):
1635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1636 
    if mtype == TMessageType.EXCEPTION:
1637 
      x = TApplicationException()
1638 
      x.read(self._iprot)
1639 
      self._iprot.readMessageEnd()
1640 
      raise x
1641 
    result = getLatestArrivals_result()
1642 
    result.read(self._iprot)
1643 
    self._iprot.readMessageEnd()
1644 
    if result.success is not None:
1645 
      return result.success
1646 
    if result.isex is not None:
1647 
      raise result.isex
1648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1649 
 
1650 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1651 
    """
1652 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1653 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1654 
 
1655 
    Parameters:
1656 
     - beginIndex
1657 
     - totalItems
1658 
     - brand
1659 
     - categories
1660 
    """
1661 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1662 
    return self.recv_getLatestArrivalsCatalogIds()
1663 
 
1664 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1665 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1666 
    args = getLatestArrivalsCatalogIds_args()
1667 
    args.beginIndex = beginIndex
1668 
    args.totalItems = totalItems
1669 
    args.brand = brand
1670 
    args.categories = categories
1671 
    args.write(self._oprot)
1672 
    self._oprot.writeMessageEnd()
1673 
    self._oprot.trans.flush()
1674 
 
1675 
  def recv_getLatestArrivalsCatalogIds(self, ):
1676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1677 
    if mtype == TMessageType.EXCEPTION:
1678 
      x = TApplicationException()
1679 
      x.read(self._iprot)
1680 
      self._iprot.readMessageEnd()
1681 
      raise x
1682 
    result = getLatestArrivalsCatalogIds_result()
1683 
    result.read(self._iprot)
1684 
    self._iprot.readMessageEnd()
1685 
    if result.success is not None:
1686 
      return result.success
1687 
    if result.cex is not None:
1688 
      raise result.cex
1689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1690 
 
1691 
  def getLatestArrivalsCount(self, ):
1692 
    """
1693 
    Get the total number of latest arrivals we are willing to show.
1694 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1695 
    """
1696 
    self.send_getLatestArrivalsCount()
1697 
    return self.recv_getLatestArrivalsCount()
1698 
 
1699 
  def send_getLatestArrivalsCount(self, ):
1700 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1701 
    args = getLatestArrivalsCount_args()
1702 
    args.write(self._oprot)
1703 
    self._oprot.writeMessageEnd()
1704 
    self._oprot.trans.flush()
1705 
 
1706 
  def recv_getLatestArrivalsCount(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 = getLatestArrivalsCount_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, "getLatestArrivalsCount failed: unknown result");
1721 
 
1722 
  def generateNewEntityID(self, ):
1723 
    self.send_generateNewEntityID()
1724 
    return self.recv_generateNewEntityID()
1725 
 
1726 
  def send_generateNewEntityID(self, ):
1727 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1728 
    args = generateNewEntityID_args()
1729 
    args.write(self._oprot)
1730 
    self._oprot.writeMessageEnd()
1731 
    self._oprot.trans.flush()
1732 
 
1733 
  def recv_generateNewEntityID(self, ):
1734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1735 
    if mtype == TMessageType.EXCEPTION:
1736 
      x = TApplicationException()
1737 
      x.read(self._iprot)
1738 
      self._iprot.readMessageEnd()
1739 
      raise x
1740 
    result = generateNewEntityID_result()
1741 
    result.read(self._iprot)
1742 
    self._iprot.readMessageEnd()
1743 
    if result.success is not None:
1744 
      return result.success
1745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1746 
 
1747 
  def addCategory(self, category):
1748 
    """
1749 
    All category related functions
1750 
 
1751 
    Parameters:
1752 
     - category
1753 
    """
1754 
    self.send_addCategory(category)
1755 
    return self.recv_addCategory()
1756 
 
1757 
  def send_addCategory(self, category):
1758 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1759 
    args = addCategory_args()
1760 
    args.category = category
1761 
    args.write(self._oprot)
1762 
    self._oprot.writeMessageEnd()
1763 
    self._oprot.trans.flush()
1764 
 
1765 
  def recv_addCategory(self, ):
1766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1767 
    if mtype == TMessageType.EXCEPTION:
1768 
      x = TApplicationException()
1769 
      x.read(self._iprot)
1770 
      self._iprot.readMessageEnd()
1771 
      raise x
1772 
    result = addCategory_result()
1773 
    result.read(self._iprot)
1774 
    self._iprot.readMessageEnd()
1775 
    if result.success is not None:
1776 
      return result.success
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1778 
 
1779 
  def getCategory(self, id):
1780 
    """
1781 
    Parameters:
1782 
     - id
1783 
    """
1784 
    self.send_getCategory(id)
1785 
    return self.recv_getCategory()
1786 
 
1787 
  def send_getCategory(self, id):
1788 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1789 
    args = getCategory_args()
1790 
    args.id = id
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getCategory(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getCategory_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
1805 
    if result.success is not None:
1806 
      return result.success
1807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1808 
 
1809 
  def getAllCategories(self, ):
1810 
    self.send_getAllCategories()
1811 
    return self.recv_getAllCategories()
1812 
 
1813 
  def send_getAllCategories(self, ):
1814 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1815 
    args = getAllCategories_args()
1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getAllCategories(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getAllCategories_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
1830 
    if result.success is not None:
1831 
      return result.success
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1833 
 
1834 
  def getAllSimilarItems(self, itemId):
1835 
    """
1836 
    Returns the list of similar items.
1837 
 
1838 
    Parameters:
1839 
     - itemId
1840 
    """
1841 
    self.send_getAllSimilarItems(itemId)
1842 
    return self.recv_getAllSimilarItems()
1843 
 
1844 
  def send_getAllSimilarItems(self, itemId):
1845 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1846 
    args = getAllSimilarItems_args()
1847 
    args.itemId = itemId
1848 
    args.write(self._oprot)
1849 
    self._oprot.writeMessageEnd()
1850 
    self._oprot.trans.flush()
1851 
 
1852 
  def recv_getAllSimilarItems(self, ):
1853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1854 
    if mtype == TMessageType.EXCEPTION:
1855 
      x = TApplicationException()
1856 
      x.read(self._iprot)
1857 
      self._iprot.readMessageEnd()
1858 
      raise x
1859 
    result = getAllSimilarItems_result()
1860 
    result.read(self._iprot)
1861 
    self._iprot.readMessageEnd()
1862 
    if result.success is not None:
1863 
      return result.success
1864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1865 
 
1866 
  def addSimilarItem(self, itemId, catalogItemId):
1867 
    """
1868 
    Adds similar item.
1869 
 
1870 
    Parameters:
1871 
     - itemId
1872 
     - catalogItemId
1873 
    """
1874 
    self.send_addSimilarItem(itemId, catalogItemId)
1875 
    return self.recv_addSimilarItem()
1876 
 
1877 
  def send_addSimilarItem(self, itemId, catalogItemId):
1878 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1879 
    args = addSimilarItem_args()
1880 
    args.itemId = itemId
1881 
    args.catalogItemId = catalogItemId
1882 
    args.write(self._oprot)
1883 
    self._oprot.writeMessageEnd()
1884 
    self._oprot.trans.flush()
1885 
 
1886 
  def recv_addSimilarItem(self, ):
1887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1888 
    if mtype == TMessageType.EXCEPTION:
1889 
      x = TApplicationException()
1890 
      x.read(self._iprot)
1891 
      self._iprot.readMessageEnd()
1892 
      raise x
1893 
    result = addSimilarItem_result()
1894 
    result.read(self._iprot)
1895 
    self._iprot.readMessageEnd()
1896 
    if result.success is not None:
1897 
      return result.success
1898 
    if result.cex is not None:
1899 
      raise result.cex
1900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1901 
 
6512 kshitij.so 1902 
  def addTag(self, displayName, itemId):
1903 
    """
1904 
    Tag Related
1905 
 
1906 
    Parameters:
1907 
     - displayName
1908 
     - itemId
1909 
    """
1910 
    self.send_addTag(displayName, itemId)
1911 
    return self.recv_addTag()
1912 
 
1913 
  def send_addTag(self, displayName, itemId):
1914 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1915 
    args = addTag_args()
1916 
    args.displayName = displayName
1917 
    args.itemId = itemId
1918 
    args.write(self._oprot)
1919 
    self._oprot.writeMessageEnd()
1920 
    self._oprot.trans.flush()
1921 
 
1922 
  def recv_addTag(self, ):
1923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1924 
    if mtype == TMessageType.EXCEPTION:
1925 
      x = TApplicationException()
1926 
      x.read(self._iprot)
1927 
      self._iprot.readMessageEnd()
1928 
      raise x
1929 
    result = addTag_result()
1930 
    result.read(self._iprot)
1931 
    self._iprot.readMessageEnd()
1932 
    if result.success is not None:
1933 
      return result.success
1934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1935 
 
1936 
  def deleteEntityTag(self, displayName, itemId):
1937 
    """
1938 
    Parameters:
1939 
     - displayName
1940 
     - itemId
1941 
    """
1942 
    self.send_deleteEntityTag(displayName, itemId)
1943 
    return self.recv_deleteEntityTag()
1944 
 
1945 
  def send_deleteEntityTag(self, displayName, itemId):
1946 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1947 
    args = deleteEntityTag_args()
1948 
    args.displayName = displayName
1949 
    args.itemId = itemId
1950 
    args.write(self._oprot)
1951 
    self._oprot.writeMessageEnd()
1952 
    self._oprot.trans.flush()
1953 
 
1954 
  def recv_deleteEntityTag(self, ):
1955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1956 
    if mtype == TMessageType.EXCEPTION:
1957 
      x = TApplicationException()
1958 
      x.read(self._iprot)
1959 
      self._iprot.readMessageEnd()
1960 
      raise x
1961 
    result = deleteEntityTag_result()
1962 
    result.read(self._iprot)
1963 
    self._iprot.readMessageEnd()
1964 
    if result.success is not None:
1965 
      return result.success
1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1967 
 
1968 
  def deleteTag(self, displayName):
1969 
    """
1970 
    Parameters:
1971 
     - displayName
1972 
    """
1973 
    self.send_deleteTag(displayName)
1974 
    return self.recv_deleteTag()
1975 
 
1976 
  def send_deleteTag(self, displayName):
1977 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1978 
    args = deleteTag_args()
1979 
    args.displayName = displayName
1980 
    args.write(self._oprot)
1981 
    self._oprot.writeMessageEnd()
1982 
    self._oprot.trans.flush()
1983 
 
1984 
  def recv_deleteTag(self, ):
1985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1986 
    if mtype == TMessageType.EXCEPTION:
1987 
      x = TApplicationException()
1988 
      x.read(self._iprot)
1989 
      self._iprot.readMessageEnd()
1990 
      raise x
1991 
    result = deleteTag_result()
1992 
    result.read(self._iprot)
1993 
    self._iprot.readMessageEnd()
1994 
    if result.success is not None:
1995 
      return result.success
1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1997 
 
1998 
  def getAllTags(self, ):
1999 
    self.send_getAllTags()
2000 
    return self.recv_getAllTags()
2001 
 
2002 
  def send_getAllTags(self, ):
2003 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2004 
    args = getAllTags_args()
2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_getAllTags(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = getAllTags_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
2019 
    if result.success is not None:
2020 
      return result.success
2021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2022 
 
2023 
  def getAllEntitiesByTagName(self, displayName):
2024 
    """
2025 
    Parameters:
2026 
     - displayName
2027 
    """
2028 
    self.send_getAllEntitiesByTagName(displayName)
2029 
    return self.recv_getAllEntitiesByTagName()
2030 
 
2031 
  def send_getAllEntitiesByTagName(self, displayName):
2032 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2033 
    args = getAllEntitiesByTagName_args()
2034 
    args.displayName = displayName
2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
2039 
  def recv_getAllEntitiesByTagName(self, ):
2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
2046 
    result = getAllEntitiesByTagName_result()
2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
2049 
    if result.success is not None:
2050 
      return result.success
2051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2052 
 
6845 amit.gupta 2053 
  def getAllEntityTags(self, ):
2054 
    self.send_getAllEntityTags()
2055 
    return self.recv_getAllEntityTags()
2056 
 
2057 
  def send_getAllEntityTags(self, ):
2058 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2059 
    args = getAllEntityTags_args()
2060 
    args.write(self._oprot)
2061 
    self._oprot.writeMessageEnd()
2062 
    self._oprot.trans.flush()
2063 
 
2064 
  def recv_getAllEntityTags(self, ):
2065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2066 
    if mtype == TMessageType.EXCEPTION:
2067 
      x = TApplicationException()
2068 
      x.read(self._iprot)
2069 
      self._iprot.readMessageEnd()
2070 
      raise x
2071 
    result = getAllEntityTags_result()
2072 
    result.read(self._iprot)
2073 
    self._iprot.readMessageEnd()
2074 
    if result.success is not None:
2075 
      return result.success
2076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2077 
 
6850 kshitij.so 2078 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2079 
    """
2080 
    Parameters:
2081 
     - bannerName
2082 
     - imageName
2083 
     - link
2084 
     - priority
2085 
     - isActive
2086 
     - hasMap
2087 
    """
2088 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2089 
    return self.recv_addBanner()
2090 
 
2091 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2092 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2093 
    args = addBanner_args()
2094 
    args.bannerName = bannerName
2095 
    args.imageName = imageName
2096 
    args.link = link
2097 
    args.priority = priority
2098 
    args.isActive = isActive
2099 
    args.hasMap = hasMap
2100 
    args.write(self._oprot)
2101 
    self._oprot.writeMessageEnd()
2102 
    self._oprot.trans.flush()
2103 
 
2104 
  def recv_addBanner(self, ):
2105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2106 
    if mtype == TMessageType.EXCEPTION:
2107 
      x = TApplicationException()
2108 
      x.read(self._iprot)
2109 
      self._iprot.readMessageEnd()
2110 
      raise x
2111 
    result = addBanner_result()
2112 
    result.read(self._iprot)
2113 
    self._iprot.readMessageEnd()
2114 
    if result.success is not None:
2115 
      return result.success
2116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2117 
 
2118 
  def getAllBanners(self, ):
2119 
    self.send_getAllBanners()
2120 
    return self.recv_getAllBanners()
2121 
 
2122 
  def send_getAllBanners(self, ):
2123 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2124 
    args = getAllBanners_args()
2125 
    args.write(self._oprot)
2126 
    self._oprot.writeMessageEnd()
2127 
    self._oprot.trans.flush()
2128 
 
2129 
  def recv_getAllBanners(self, ):
2130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2131 
    if mtype == TMessageType.EXCEPTION:
2132 
      x = TApplicationException()
2133 
      x.read(self._iprot)
2134 
      self._iprot.readMessageEnd()
2135 
      raise x
2136 
    result = getAllBanners_result()
2137 
    result.read(self._iprot)
2138 
    self._iprot.readMessageEnd()
2139 
    if result.success is not None:
2140 
      return result.success
2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2142 
 
2143 
  def deleteBanner(self, bannerName):
2144 
    """
2145 
    Parameters:
2146 
     - bannerName
2147 
    """
2148 
    self.send_deleteBanner(bannerName)
2149 
    return self.recv_deleteBanner()
2150 
 
2151 
  def send_deleteBanner(self, bannerName):
2152 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2153 
    args = deleteBanner_args()
2154 
    args.bannerName = bannerName
2155 
    args.write(self._oprot)
2156 
    self._oprot.writeMessageEnd()
2157 
    self._oprot.trans.flush()
2158 
 
2159 
  def recv_deleteBanner(self, ):
2160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2161 
    if mtype == TMessageType.EXCEPTION:
2162 
      x = TApplicationException()
2163 
      x.read(self._iprot)
2164 
      self._iprot.readMessageEnd()
2165 
      raise x
2166 
    result = deleteBanner_result()
2167 
    result.read(self._iprot)
2168 
    self._iprot.readMessageEnd()
2169 
    if result.success is not None:
2170 
      return result.success
2171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2172 
 
2173 
  def getBannerDetails(self, bannerName):
2174 
    """
2175 
    Parameters:
2176 
     - bannerName
2177 
    """
2178 
    self.send_getBannerDetails(bannerName)
2179 
    return self.recv_getBannerDetails()
2180 
 
2181 
  def send_getBannerDetails(self, bannerName):
2182 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2183 
    args = getBannerDetails_args()
2184 
    args.bannerName = bannerName
2185 
    args.write(self._oprot)
2186 
    self._oprot.writeMessageEnd()
2187 
    self._oprot.trans.flush()
2188 
 
2189 
  def recv_getBannerDetails(self, ):
2190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2191 
    if mtype == TMessageType.EXCEPTION:
2192 
      x = TApplicationException()
2193 
      x.read(self._iprot)
2194 
      self._iprot.readMessageEnd()
2195 
      raise x
2196 
    result = getBannerDetails_result()
2197 
    result.read(self._iprot)
2198 
    self._iprot.readMessageEnd()
2199 
    if result.success is not None:
2200 
      return result.success
2201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2202 
 
2203 
  def getActiveBanners(self, ):
2204 
    self.send_getActiveBanners()
2205 
    return self.recv_getActiveBanners()
2206 
 
2207 
  def send_getActiveBanners(self, ):
2208 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2209 
    args = getActiveBanners_args()
2210 
    args.write(self._oprot)
2211 
    self._oprot.writeMessageEnd()
2212 
    self._oprot.trans.flush()
2213 
 
2214 
  def recv_getActiveBanners(self, ):
2215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2216 
    if mtype == TMessageType.EXCEPTION:
2217 
      x = TApplicationException()
2218 
      x.read(self._iprot)
2219 
      self._iprot.readMessageEnd()
2220 
      raise x
2221 
    result = getActiveBanners_result()
2222 
    result.read(self._iprot)
2223 
    self._iprot.readMessageEnd()
2224 
    if result.success is not None:
2225 
      return result.success
2226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2227 
 
6849 kshitij.so 2228 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2229 
    """
2230 
    Parameters:
2231 
     - bannerName
2232 
     - mapLink
2233 
     - coordinates
2234 
    """
2235 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2236 
    return self.recv_addBannerMap()
2237 
 
2238 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2239 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2240 
    args = addBannerMap_args()
2241 
    args.bannerName = bannerName
2242 
    args.mapLink = mapLink
2243 
    args.coordinates = coordinates
2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
2248 
  def recv_addBannerMap(self, ):
2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
2255 
    result = addBannerMap_result()
2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
2258 
    if result.success is not None:
2259 
      return result.success
2260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2261 
 
2262 
  def deleteBannerMap(self, bannerName):
2263 
    """
2264 
    Parameters:
2265 
     - bannerName
2266 
    """
2267 
    self.send_deleteBannerMap(bannerName)
2268 
    return self.recv_deleteBannerMap()
2269 
 
2270 
  def send_deleteBannerMap(self, bannerName):
2271 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2272 
    args = deleteBannerMap_args()
2273 
    args.bannerName = bannerName
2274 
    args.write(self._oprot)
2275 
    self._oprot.writeMessageEnd()
2276 
    self._oprot.trans.flush()
2277 
 
2278 
  def recv_deleteBannerMap(self, ):
2279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2280 
    if mtype == TMessageType.EXCEPTION:
2281 
      x = TApplicationException()
2282 
      x.read(self._iprot)
2283 
      self._iprot.readMessageEnd()
2284 
      raise x
2285 
    result = deleteBannerMap_result()
2286 
    result.read(self._iprot)
2287 
    self._iprot.readMessageEnd()
2288 
    if result.success is not None:
2289 
      return result.success
2290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2291 
 
2292 
  def getBannerMapDetails(self, bannerName):
2293 
    """
2294 
    Parameters:
2295 
     - bannerName
2296 
    """
2297 
    self.send_getBannerMapDetails(bannerName)
2298 
    return self.recv_getBannerMapDetails()
2299 
 
2300 
  def send_getBannerMapDetails(self, bannerName):
2301 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2302 
    args = getBannerMapDetails_args()
2303 
    args.bannerName = bannerName
2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_getBannerMapDetails(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = getBannerMapDetails_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
2318 
    if result.success is not None:
2319 
      return result.success
2320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2321 
 
5944 mandeep.dh 2322 
  def deleteSimilarItem(self, itemId, catalogItemId):
2323 
    """
2324 
    Delete similar item.
2325 
 
2326 
    Parameters:
2327 
     - itemId
2328 
     - catalogItemId
2329 
    """
2330 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2331 
    return self.recv_deleteSimilarItem()
2332 
 
2333 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2334 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2335 
    args = deleteSimilarItem_args()
2336 
    args.itemId = itemId
2337 
    args.catalogItemId = catalogItemId
2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
2342 
  def recv_deleteSimilarItem(self, ):
2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
2349 
    result = deleteSimilarItem_result()
2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
2352 
    if result.success is not None:
2353 
      return result.success
2354 
    if result.cex is not None:
2355 
      raise result.cex
2356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2357 
 
2358 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2359 
    """
2360 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2361 
    If yes, returns the itemId else returns 0
2362 
 
2363 
    Parameters:
2364 
     - brand
2365 
     - modelNumber
2366 
     - modelName
2367 
     - color
2368 
    """
2369 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2370 
    return self.recv_checkSimilarItem()
2371 
 
2372 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2373 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2374 
    args = checkSimilarItem_args()
2375 
    args.brand = brand
2376 
    args.modelNumber = modelNumber
2377 
    args.modelName = modelName
2378 
    args.color = color
2379 
    args.write(self._oprot)
2380 
    self._oprot.writeMessageEnd()
2381 
    self._oprot.trans.flush()
2382 
 
2383 
  def recv_checkSimilarItem(self, ):
2384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2385 
    if mtype == TMessageType.EXCEPTION:
2386 
      x = TApplicationException()
2387 
      x.read(self._iprot)
2388 
      self._iprot.readMessageEnd()
2389 
      raise x
2390 
    result = checkSimilarItem_result()
2391 
    result.read(self._iprot)
2392 
    self._iprot.readMessageEnd()
2393 
    if result.success is not None:
2394 
      return result.success
2395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2396 
 
2397 
  def validateRiskyStatus(self, itemId):
2398 
    """
2399 
    Check wether item is risky and change status if inventory is not available for risky items
2400 
 
2401 
    Parameters:
2402 
     - itemId
2403 
    """
2404 
    self.send_validateRiskyStatus(itemId)
2405 
    self.recv_validateRiskyStatus()
2406 
 
2407 
  def send_validateRiskyStatus(self, itemId):
2408 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2409 
    args = validateRiskyStatus_args()
2410 
    args.itemId = itemId
2411 
    args.write(self._oprot)
2412 
    self._oprot.writeMessageEnd()
2413 
    self._oprot.trans.flush()
2414 
 
2415 
  def recv_validateRiskyStatus(self, ):
2416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2417 
    if mtype == TMessageType.EXCEPTION:
2418 
      x = TApplicationException()
2419 
      x.read(self._iprot)
2420 
      self._iprot.readMessageEnd()
2421 
      raise x
2422 
    result = validateRiskyStatus_result()
2423 
    result.read(self._iprot)
2424 
    self._iprot.readMessageEnd()
2425 
    return
2426 
 
2427 
  def changeItemRiskyFlag(self, itemId, risky):
2428 
    """
2429 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2430 
 
2431 
    Parameters:
2432 
     - itemId
2433 
     - risky
2434 
    """
2435 
    self.send_changeItemRiskyFlag(itemId, risky)
2436 
    self.recv_changeItemRiskyFlag()
2437 
 
2438 
  def send_changeItemRiskyFlag(self, itemId, risky):
2439 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2440 
    args = changeItemRiskyFlag_args()
2441 
    args.itemId = itemId
2442 
    args.risky = risky
2443 
    args.write(self._oprot)
2444 
    self._oprot.writeMessageEnd()
2445 
    self._oprot.trans.flush()
2446 
 
2447 
  def recv_changeItemRiskyFlag(self, ):
2448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2449 
    if mtype == TMessageType.EXCEPTION:
2450 
      x = TApplicationException()
2451 
      x.read(self._iprot)
2452 
      self._iprot.readMessageEnd()
2453 
      raise x
2454 
    result = changeItemRiskyFlag_result()
2455 
    result.read(self._iprot)
2456 
    self._iprot.readMessageEnd()
2457 
    return
2458 
 
2459 
  def getItemsByRiskyFlag(self, ):
2460 
    """
2461 
    Returns list of items marked as risky.
2462 
    """
2463 
    self.send_getItemsByRiskyFlag()
2464 
    return self.recv_getItemsByRiskyFlag()
2465 
 
2466 
  def send_getItemsByRiskyFlag(self, ):
2467 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2468 
    args = getItemsByRiskyFlag_args()
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
2473 
  def recv_getItemsByRiskyFlag(self, ):
2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
2480 
    result = getItemsByRiskyFlag_result()
2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
2483 
    if result.success is not None:
2484 
      return result.success
2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2486 
 
2487 
  def getItemsForMasterSheet(self, category, brand):
2488 
    """
2489 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2490 
 
2491 
    Parameters:
2492 
     - category
2493 
     - brand
2494 
    """
2495 
    self.send_getItemsForMasterSheet(category, brand)
2496 
    return self.recv_getItemsForMasterSheet()
2497 
 
2498 
  def send_getItemsForMasterSheet(self, category, brand):
2499 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2500 
    args = getItemsForMasterSheet_args()
2501 
    args.category = category
2502 
    args.brand = brand
2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_getItemsForMasterSheet(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = getItemsForMasterSheet_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
2517 
    if result.success is not None:
2518 
      return result.success
2519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2520 
 
2521 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2522 
    """
2523 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2524 
 
2525 
    Parameters:
2526 
     - beginIndex
2527 
     - totalItems
2528 
     - itemId
2529 
    """
2530 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2531 
    return self.recv_getSimilarItemsCatalogIds()
2532 
 
2533 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2534 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2535 
    args = getSimilarItemsCatalogIds_args()
2536 
    args.beginIndex = beginIndex
2537 
    args.totalItems = totalItems
2538 
    args.itemId = itemId
2539 
    args.write(self._oprot)
2540 
    self._oprot.writeMessageEnd()
2541 
    self._oprot.trans.flush()
2542 
 
2543 
  def recv_getSimilarItemsCatalogIds(self, ):
2544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2545 
    if mtype == TMessageType.EXCEPTION:
2546 
      x = TApplicationException()
2547 
      x.read(self._iprot)
2548 
      self._iprot.readMessageEnd()
2549 
      raise x
2550 
    result = getSimilarItemsCatalogIds_result()
2551 
    result.read(self._iprot)
2552 
    self._iprot.readMessageEnd()
2553 
    if result.success is not None:
2554 
      return result.success
2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2556 
 
2557 
  def addProductNotification(self, itemId, email):
2558 
    """
2559 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2560 
 
2561 
    Parameters:
2562 
     - itemId
2563 
     - email
2564 
    """
2565 
    self.send_addProductNotification(itemId, email)
2566 
    return self.recv_addProductNotification()
2567 
 
2568 
  def send_addProductNotification(self, itemId, email):
2569 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2570 
    args = addProductNotification_args()
2571 
    args.itemId = itemId
2572 
    args.email = email
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_addProductNotification(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = addProductNotification_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    if result.success is not None:
2588 
      return result.success
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2590 
 
2591 
  def sendProductNotifications(self, ):
2592 
    """
2593 
    Send the product notifications to the users for items which has stock.
2594 
    """
2595 
    self.send_sendProductNotifications()
2596 
    return self.recv_sendProductNotifications()
2597 
 
2598 
  def send_sendProductNotifications(self, ):
2599 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2600 
    args = sendProductNotifications_args()
2601 
    args.write(self._oprot)
2602 
    self._oprot.writeMessageEnd()
2603 
    self._oprot.trans.flush()
2604 
 
2605 
  def recv_sendProductNotifications(self, ):
2606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2607 
    if mtype == TMessageType.EXCEPTION:
2608 
      x = TApplicationException()
2609 
      x.read(self._iprot)
2610 
      self._iprot.readMessageEnd()
2611 
      raise x
2612 
    result = sendProductNotifications_result()
2613 
    result.read(self._iprot)
2614 
    self._iprot.readMessageEnd()
2615 
    if result.success is not None:
2616 
      return result.success
2617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2618 
 
2619 
  def getAllBrandsByCategory(self, categoryId):
2620 
    """
2621 
    Returns list of brand names for a given category Id
2622 
 
2623 
    Parameters:
2624 
     - categoryId
2625 
    """
2626 
    self.send_getAllBrandsByCategory(categoryId)
2627 
    return self.recv_getAllBrandsByCategory()
2628 
 
2629 
  def send_getAllBrandsByCategory(self, categoryId):
2630 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2631 
    args = getAllBrandsByCategory_args()
2632 
    args.categoryId = categoryId
2633 
    args.write(self._oprot)
2634 
    self._oprot.writeMessageEnd()
2635 
    self._oprot.trans.flush()
2636 
 
2637 
  def recv_getAllBrandsByCategory(self, ):
2638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2639 
    if mtype == TMessageType.EXCEPTION:
2640 
      x = TApplicationException()
2641 
      x.read(self._iprot)
2642 
      self._iprot.readMessageEnd()
2643 
      raise x
2644 
    result = getAllBrandsByCategory_result()
2645 
    result.read(self._iprot)
2646 
    self._iprot.readMessageEnd()
2647 
    if result.success is not None:
2648 
      return result.success
2649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2650 
 
2651 
  def getAllBrands(self, ):
2652 
    """
2653 
    Returns list of brand names
2654 
    """
2655 
    self.send_getAllBrands()
2656 
    return self.recv_getAllBrands()
2657 
 
2658 
  def send_getAllBrands(self, ):
2659 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2660 
    args = getAllBrands_args()
2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_getAllBrands(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = getAllBrands_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
2675 
    if result.success is not None:
2676 
      return result.success
2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2678 
 
2679 
  def getAllSources(self, ):
2680 
    """
2681 
    Return list of all sources
2682 
    """
2683 
    self.send_getAllSources()
2684 
    return self.recv_getAllSources()
2685 
 
2686 
  def send_getAllSources(self, ):
2687 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2688 
    args = getAllSources_args()
2689 
    args.write(self._oprot)
2690 
    self._oprot.writeMessageEnd()
2691 
    self._oprot.trans.flush()
2692 
 
2693 
  def recv_getAllSources(self, ):
2694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2695 
    if mtype == TMessageType.EXCEPTION:
2696 
      x = TApplicationException()
2697 
      x.read(self._iprot)
2698 
      self._iprot.readMessageEnd()
2699 
      raise x
2700 
    result = getAllSources_result()
2701 
    result.read(self._iprot)
2702 
    self._iprot.readMessageEnd()
2703 
    if result.success is not None:
2704 
      return result.success
2705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2706 
 
2707 
  def getItemPricingBySource(self, itemId, sourceId):
2708 
    """
2709 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2710 
 
2711 
    Parameters:
2712 
     - itemId
2713 
     - sourceId
2714 
    """
2715 
    self.send_getItemPricingBySource(itemId, sourceId)
2716 
    return self.recv_getItemPricingBySource()
2717 
 
2718 
  def send_getItemPricingBySource(self, itemId, sourceId):
2719 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2720 
    args = getItemPricingBySource_args()
2721 
    args.itemId = itemId
2722 
    args.sourceId = sourceId
2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
2727 
  def recv_getItemPricingBySource(self, ):
2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
2734 
    result = getItemPricingBySource_result()
2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
2737 
    if result.success is not None:
2738 
      return result.success
2739 
    if result.cex is not None:
2740 
      raise result.cex
2741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2742 
 
2743 
  def addSourceItemPricing(self, sourceItemPricing):
2744 
    """
2745 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2746 
    If item is not found or source is not found, it will throw exception.
2747 
 
2748 
    Parameters:
2749 
     - sourceItemPricing
2750 
    """
2751 
    self.send_addSourceItemPricing(sourceItemPricing)
2752 
    self.recv_addSourceItemPricing()
2753 
 
2754 
  def send_addSourceItemPricing(self, sourceItemPricing):
2755 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2756 
    args = addSourceItemPricing_args()
2757 
    args.sourceItemPricing = sourceItemPricing
2758 
    args.write(self._oprot)
2759 
    self._oprot.writeMessageEnd()
2760 
    self._oprot.trans.flush()
2761 
 
2762 
  def recv_addSourceItemPricing(self, ):
2763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2764 
    if mtype == TMessageType.EXCEPTION:
2765 
      x = TApplicationException()
2766 
      x.read(self._iprot)
2767 
      self._iprot.readMessageEnd()
2768 
      raise x
2769 
    result = addSourceItemPricing_result()
2770 
    result.read(self._iprot)
2771 
    self._iprot.readMessageEnd()
2772 
    if result.cex is not None:
2773 
      raise result.cex
2774 
    return
2775 
 
2776 
  def getAllSourcePricing(self, itemId):
2777 
    """
2778 
    Returns the list of source pricing information of an item.
2779 
    Raises an exception if item not found corresponding to itemId
2780 
 
2781 
    Parameters:
2782 
     - itemId
2783 
    """
2784 
    self.send_getAllSourcePricing(itemId)
2785 
    return self.recv_getAllSourcePricing()
2786 
 
2787 
  def send_getAllSourcePricing(self, itemId):
2788 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2789 
    args = getAllSourcePricing_args()
2790 
    args.itemId = itemId
2791 
    args.write(self._oprot)
2792 
    self._oprot.writeMessageEnd()
2793 
    self._oprot.trans.flush()
2794 
 
2795 
  def recv_getAllSourcePricing(self, ):
2796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2797 
    if mtype == TMessageType.EXCEPTION:
2798 
      x = TApplicationException()
2799 
      x.read(self._iprot)
2800 
      self._iprot.readMessageEnd()
2801 
      raise x
2802 
    result = getAllSourcePricing_result()
2803 
    result.read(self._iprot)
2804 
    self._iprot.readMessageEnd()
2805 
    if result.success is not None:
2806 
      return result.success
2807 
    if result.cex is not None:
2808 
      raise result.cex
2809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2810 
 
2811 
  def getItemForSource(self, item_id, sourceId):
2812 
    """
2813 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2814 
 
2815 
    Parameters:
2816 
     - item_id
2817 
     - sourceId
2818 
    """
2819 
    self.send_getItemForSource(item_id, sourceId)
2820 
    return self.recv_getItemForSource()
2821 
 
2822 
  def send_getItemForSource(self, item_id, sourceId):
2823 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2824 
    args = getItemForSource_args()
2825 
    args.item_id = item_id
2826 
    args.sourceId = sourceId
2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
2831 
  def recv_getItemForSource(self, ):
2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
2838 
    result = getItemForSource_result()
2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
2841 
    if result.success is not None:
2842 
      return result.success
2843 
    if result.cex is not None:
2844 
      raise result.cex
2845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2846 
 
2847 
  def searchItemsInRange(self, searchTerms, offset, limit):
2848 
    """
2849 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2850 
 
2851 
    Parameters:
2852 
     - searchTerms
2853 
     - offset
2854 
     - limit
2855 
    """
2856 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2857 
    return self.recv_searchItemsInRange()
2858 
 
2859 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2860 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2861 
    args = searchItemsInRange_args()
2862 
    args.searchTerms = searchTerms
2863 
    args.offset = offset
2864 
    args.limit = limit
2865 
    args.write(self._oprot)
2866 
    self._oprot.writeMessageEnd()
2867 
    self._oprot.trans.flush()
2868 
 
2869 
  def recv_searchItemsInRange(self, ):
2870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2871 
    if mtype == TMessageType.EXCEPTION:
2872 
      x = TApplicationException()
2873 
      x.read(self._iprot)
2874 
      self._iprot.readMessageEnd()
2875 
      raise x
2876 
    result = searchItemsInRange_result()
2877 
    result.read(self._iprot)
2878 
    self._iprot.readMessageEnd()
2879 
    if result.success is not None:
2880 
      return result.success
2881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2882 
 
2883 
  def getSearchResultCount(self, searchTerms):
2884 
    """
2885 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2886 
 
2887 
    Parameters:
2888 
     - searchTerms
2889 
    """
2890 
    self.send_getSearchResultCount(searchTerms)
2891 
    return self.recv_getSearchResultCount()
2892 
 
2893 
  def send_getSearchResultCount(self, searchTerms):
2894 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2895 
    args = getSearchResultCount_args()
2896 
    args.searchTerms = searchTerms
2897 
    args.write(self._oprot)
2898 
    self._oprot.writeMessageEnd()
2899 
    self._oprot.trans.flush()
2900 
 
2901 
  def recv_getSearchResultCount(self, ):
2902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2903 
    if mtype == TMessageType.EXCEPTION:
2904 
      x = TApplicationException()
2905 
      x.read(self._iprot)
2906 
      self._iprot.readMessageEnd()
2907 
      raise x
2908 
    result = getSearchResultCount_result()
2909 
    result.read(self._iprot)
2910 
    self._iprot.readMessageEnd()
2911 
    if result.success is not None:
2912 
      return result.success
2913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2914 
 
2915 
  def getProductNotifications(self, startDateTime):
2916 
    """
2917 
    Returns a list of product notifications added after a supplied datetime
2918 
 
2919 
    Parameters:
2920 
     - startDateTime
2921 
    """
2922 
    self.send_getProductNotifications(startDateTime)
2923 
    return self.recv_getProductNotifications()
2924 
 
2925 
  def send_getProductNotifications(self, startDateTime):
2926 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2927 
    args = getProductNotifications_args()
2928 
    args.startDateTime = startDateTime
2929 
    args.write(self._oprot)
2930 
    self._oprot.writeMessageEnd()
2931 
    self._oprot.trans.flush()
2932 
 
2933 
  def recv_getProductNotifications(self, ):
2934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2935 
    if mtype == TMessageType.EXCEPTION:
2936 
      x = TApplicationException()
2937 
      x.read(self._iprot)
2938 
      self._iprot.readMessageEnd()
2939 
      raise x
2940 
    result = getProductNotifications_result()
2941 
    result.read(self._iprot)
2942 
    self._iprot.readMessageEnd()
2943 
    if result.success is not None:
2944 
      return result.success
2945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2946 
 
2947 
  def getProductNotificationRequestCount(self, startDateTime):
2948 
    """
2949 
    Returns a list of count of requests for product notification against each item
2950 
 
2951 
    Parameters:
2952 
     - startDateTime
2953 
    """
2954 
    self.send_getProductNotificationRequestCount(startDateTime)
2955 
    return self.recv_getProductNotificationRequestCount()
2956 
 
2957 
  def send_getProductNotificationRequestCount(self, startDateTime):
2958 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2959 
    args = getProductNotificationRequestCount_args()
2960 
    args.startDateTime = startDateTime
2961 
    args.write(self._oprot)
2962 
    self._oprot.writeMessageEnd()
2963 
    self._oprot.trans.flush()
2964 
 
2965 
  def recv_getProductNotificationRequestCount(self, ):
2966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2967 
    if mtype == TMessageType.EXCEPTION:
2968 
      x = TApplicationException()
2969 
      x.read(self._iprot)
2970 
      self._iprot.readMessageEnd()
2971 
      raise x
2972 
    result = getProductNotificationRequestCount_result()
2973 
    result.read(self._iprot)
2974 
    self._iprot.readMessageEnd()
2975 
    if result.success is not None:
2976 
      return result.success
2977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2978 
 
2979 
  def addAuthorizationLog(self, itemId, username, reason):
2980 
    """
2981 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2982 
 
2983 
    Parameters:
2984 
     - itemId
2985 
     - username
2986 
     - reason
2987 
    """
2988 
    self.send_addAuthorizationLog(itemId, username, reason)
2989 
    return self.recv_addAuthorizationLog()
2990 
 
2991 
  def send_addAuthorizationLog(self, itemId, username, reason):
2992 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2993 
    args = addAuthorizationLog_args()
2994 
    args.itemId = itemId
2995 
    args.username = username
2996 
    args.reason = reason
2997 
    args.write(self._oprot)
2998 
    self._oprot.writeMessageEnd()
2999 
    self._oprot.trans.flush()
3000 
 
3001 
  def recv_addAuthorizationLog(self, ):
3002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3003 
    if mtype == TMessageType.EXCEPTION:
3004 
      x = TApplicationException()
3005 
      x.read(self._iprot)
3006 
      self._iprot.readMessageEnd()
3007 
      raise x
3008 
    result = addAuthorizationLog_result()
3009 
    result.read(self._iprot)
3010 
    self._iprot.readMessageEnd()
3011 
    if result.success is not None:
3012 
      return result.success
3013 
    if result.cex is not None:
3014 
      raise result.cex
3015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3016 
 
3017 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3018 
    """
3019 
    Parameters:
3020 
     - catalog_item_id
3021 
     - voucherType
3022 
     - voucherAmount
3023 
    """
3024 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3025 
    return self.recv_addupdateVoucherForItem()
3026 
 
3027 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3028 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3029 
    args = addupdateVoucherForItem_args()
3030 
    args.catalog_item_id = catalog_item_id
3031 
    args.voucherType = voucherType
3032 
    args.voucherAmount = voucherAmount
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_addupdateVoucherForItem(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = addupdateVoucherForItem_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3047 
    if result.success is not None:
3048 
      return result.success
3049 
    if result.cex is not None:
3050 
      raise result.cex
3051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3052 
 
3053 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3054 
    """
3055 
    Parameters:
3056 
     - catalog_item_id
3057 
     - voucherType
3058 
    """
3059 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3060 
    return self.recv_deleteVoucherForItem()
3061 
 
3062 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3063 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3064 
    args = deleteVoucherForItem_args()
3065 
    args.catalog_item_id = catalog_item_id
3066 
    args.voucherType = voucherType
3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_deleteVoucherForItem(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = deleteVoucherForItem_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3081 
    if result.success is not None:
3082 
      return result.success
3083 
    if result.cex is not None:
3084 
      raise result.cex
3085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3086 
 
3087 
  def getVoucherAmount(self, itemId, voucherType):
3088 
    """
3089 
    Parameters:
3090 
     - itemId
3091 
     - voucherType
3092 
    """
3093 
    self.send_getVoucherAmount(itemId, voucherType)
3094 
    return self.recv_getVoucherAmount()
3095 
 
3096 
  def send_getVoucherAmount(self, itemId, voucherType):
3097 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3098 
    args = getVoucherAmount_args()
3099 
    args.itemId = itemId
3100 
    args.voucherType = voucherType
3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_getVoucherAmount(self, ):
3106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3107 
    if mtype == TMessageType.EXCEPTION:
3108 
      x = TApplicationException()
3109 
      x.read(self._iprot)
3110 
      self._iprot.readMessageEnd()
3111 
      raise x
3112 
    result = getVoucherAmount_result()
3113 
    result.read(self._iprot)
3114 
    self._iprot.readMessageEnd()
3115 
    if result.success is not None:
3116 
      return result.success
3117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3118 
 
3119 
  def getAllItemVouchers(self, itemId):
3120 
    """
3121 
    Parameters:
3122 
     - itemId
3123 
    """
3124 
    self.send_getAllItemVouchers(itemId)
3125 
    return self.recv_getAllItemVouchers()
3126 
 
3127 
  def send_getAllItemVouchers(self, itemId):
3128 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3129 
    args = getAllItemVouchers_args()
3130 
    args.itemId = itemId
3131 
    args.write(self._oprot)
3132 
    self._oprot.writeMessageEnd()
3133 
    self._oprot.trans.flush()
3134 
 
3135 
  def recv_getAllItemVouchers(self, ):
3136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3137 
    if mtype == TMessageType.EXCEPTION:
3138 
      x = TApplicationException()
3139 
      x.read(self._iprot)
3140 
      self._iprot.readMessageEnd()
3141 
      raise x
3142 
    result = getAllItemVouchers_result()
3143 
    result.read(self._iprot)
3144 
    self._iprot.readMessageEnd()
3145 
    if result.success is not None:
3146 
      return result.success
3147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3148 
 
3149 
  def isValidCatalogItemId(self, catalog_item_id):
3150 
    """
3151 
    Parameters:
3152 
     - catalog_item_id
3153 
    """
3154 
    self.send_isValidCatalogItemId(catalog_item_id)
3155 
    return self.recv_isValidCatalogItemId()
3156 
 
3157 
  def send_isValidCatalogItemId(self, catalog_item_id):
3158 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3159 
    args = isValidCatalogItemId_args()
3160 
    args.catalog_item_id = catalog_item_id
3161 
    args.write(self._oprot)
3162 
    self._oprot.writeMessageEnd()
3163 
    self._oprot.trans.flush()
3164 
 
3165 
  def recv_isValidCatalogItemId(self, ):
3166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3167 
    if mtype == TMessageType.EXCEPTION:
3168 
      x = TApplicationException()
3169 
      x.read(self._iprot)
3170 
      self._iprot.readMessageEnd()
3171 
      raise x
3172 
    result = isValidCatalogItemId_result()
3173 
    result.read(self._iprot)
3174 
    self._iprot.readMessageEnd()
3175 
    if result.success is not None:
3176 
      return result.success
3177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3178 
 
7330 amit.gupta 3179 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3180 
    """
3181 
    Parameters:
3182 
     - itemId
7330 amit.gupta 3183 
     - stateId
6039 amit.gupta 3184 
     - price
3185 
    """
7330 amit.gupta 3186 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3187 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3188 
 
7330 amit.gupta 3189 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3190 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3191 
    args = getVatPercentageForItem_args()
3192 
    args.itemId = itemId
7330 amit.gupta 3193 
    args.stateId = stateId
6039 amit.gupta 3194 
    args.price = price
3195 
    args.write(self._oprot)
3196 
    self._oprot.writeMessageEnd()
3197 
    self._oprot.trans.flush()
3198 
 
3199 
  def recv_getVatPercentageForItem(self, ):
3200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3201 
    if mtype == TMessageType.EXCEPTION:
3202 
      x = TApplicationException()
3203 
      x.read(self._iprot)
3204 
      self._iprot.readMessageEnd()
3205 
      raise x
3206 
    result = getVatPercentageForItem_result()
3207 
    result.read(self._iprot)
3208 
    self._iprot.readMessageEnd()
3209 
    if result.success is not None:
3210 
      return result.success
7340 amit.gupta 3211 
    if result.cex is not None:
3212 
      raise result.cex
6039 amit.gupta 3213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3214 
 
3215 
  def getVatAmountForItem(self, itemId, price):
3216 
    """
3217 
    Parameters:
3218 
     - itemId
3219 
     - price
3220 
    """
3221 
    self.send_getVatAmountForItem(itemId, price)
3222 
    return self.recv_getVatAmountForItem()
3223 
 
3224 
  def send_getVatAmountForItem(self, itemId, price):
3225 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3226 
    args = getVatAmountForItem_args()
3227 
    args.itemId = itemId
3228 
    args.price = price
3229 
    args.write(self._oprot)
3230 
    self._oprot.writeMessageEnd()
3231 
    self._oprot.trans.flush()
3232 
 
3233 
  def recv_getVatAmountForItem(self, ):
3234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3235 
    if mtype == TMessageType.EXCEPTION:
3236 
      x = TApplicationException()
3237 
      x.read(self._iprot)
3238 
      self._iprot.readMessageEnd()
3239 
      raise x
3240 
    result = getVatAmountForItem_result()
3241 
    result.read(self._iprot)
3242 
    self._iprot.readMessageEnd()
3243 
    if result.success is not None:
3244 
      return result.success
3245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3246 
 
6531 vikram.rag 3247 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3248 
    """
3249 
    Parameters:
3250 
     - offset
3251 
     - limit
3252 
    """
3253 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3254 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3255 
 
6531 vikram.rag 3256 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3257 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3258 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3259 
    args.offset = offset
3260 
    args.limit = limit
3261 
    args.write(self._oprot)
3262 
    self._oprot.writeMessageEnd()
3263 
    self._oprot.trans.flush()
3264 
 
3265 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3267 
    if mtype == TMessageType.EXCEPTION:
3268 
      x = TApplicationException()
3269 
      x.read(self._iprot)
3270 
      self._iprot.readMessageEnd()
3271 
      raise x
3272 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3273 
    result.read(self._iprot)
3274 
    self._iprot.readMessageEnd()
3275 
    if result.success is not None:
3276 
      return result.success
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3278 
 
6821 amar.kumar 3279 
  def getAllAliveItems(self, ):
3280 
    self.send_getAllAliveItems()
3281 
    return self.recv_getAllAliveItems()
3282 
 
3283 
  def send_getAllAliveItems(self, ):
3284 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3285 
    args = getAllAliveItems_args()
3286 
    args.write(self._oprot)
3287 
    self._oprot.writeMessageEnd()
3288 
    self._oprot.trans.flush()
3289 
 
3290 
  def recv_getAllAliveItems(self, ):
3291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3292 
    if mtype == TMessageType.EXCEPTION:
3293 
      x = TApplicationException()
3294 
      x.read(self._iprot)
3295 
      self._iprot.readMessageEnd()
3296 
      raise x
3297 
    result = getAllAliveItems_result()
3298 
    result.read(self._iprot)
3299 
    self._iprot.readMessageEnd()
3300 
    if result.success is not None:
3301 
      return result.success
3302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3303 
 
6921 anupam.sin 3304 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3305 
    """
3306 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3307 
 
6805 anupam.sin 3308 
    Parameters:
3309 
     - itemId
6921 anupam.sin 3310 
     - price
6805 anupam.sin 3311 
     - insurerId
3312 
     - quantity
3313 
    """
6921 anupam.sin 3314 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3315 
    return self.recv_getInsuranceAmount()
3316 
 
6921 anupam.sin 3317 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3318 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3319 
    args = getInsuranceAmount_args()
3320 
    args.itemId = itemId
6921 anupam.sin 3321 
    args.price = price
6805 anupam.sin 3322 
    args.insurerId = insurerId
3323 
    args.quantity = quantity
3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3328 
  def recv_getInsuranceAmount(self, ):
3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3335 
    result = getInsuranceAmount_result()
3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3338 
    if result.success is not None:
3339 
      return result.success
3340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3341 
 
3342 
  def getInsurer(self, insurerId):
3343 
    """
3344 
    Parameters:
3345 
     - insurerId
3346 
    """
3347 
    self.send_getInsurer(insurerId)
3348 
    return self.recv_getInsurer()
3349 
 
3350 
  def send_getInsurer(self, insurerId):
3351 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3352 
    args = getInsurer_args()
3353 
    args.insurerId = insurerId
3354 
    args.write(self._oprot)
3355 
    self._oprot.writeMessageEnd()
3356 
    self._oprot.trans.flush()
3357 
 
3358 
  def recv_getInsurer(self, ):
3359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3360 
    if mtype == TMessageType.EXCEPTION:
3361 
      x = TApplicationException()
3362 
      x.read(self._iprot)
3363 
      self._iprot.readMessageEnd()
3364 
      raise x
3365 
    result = getInsurer_result()
3366 
    result.read(self._iprot)
3367 
    self._iprot.readMessageEnd()
3368 
    if result.success is not None:
3369 
      return result.success
3370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3371 
 
6838 vikram.rag 3372 
  def getAllInsurers(self, ):
3373 
    self.send_getAllInsurers()
3374 
    return self.recv_getAllInsurers()
6805 anupam.sin 3375 
 
6838 vikram.rag 3376 
  def send_getAllInsurers(self, ):
3377 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3378 
    args = getAllInsurers_args()
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_getAllInsurers(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = getAllInsurers_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3396 
 
6962 rajveer 3397 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3398 
    """
3399 
    Parameters:
3400 
     - insurerId
3401 
     - amount
3402 
    """
3403 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3404 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3405 
 
6962 rajveer 3406 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3407 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3408 
    args = updateInsuranceDeclaredAmount_args()
3409 
    args.insurerId = insurerId
3410 
    args.amount = amount
3411 
    args.write(self._oprot)
3412 
    self._oprot.writeMessageEnd()
3413 
    self._oprot.trans.flush()
3414 
 
3415 
  def recv_updateInsuranceDeclaredAmount(self, ):
3416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3417 
    if mtype == TMessageType.EXCEPTION:
3418 
      x = TApplicationException()
3419 
      x.read(self._iprot)
3420 
      self._iprot.readMessageEnd()
3421 
      raise x
3422 
    result = updateInsuranceDeclaredAmount_result()
3423 
    result.read(self._iprot)
3424 
    self._iprot.readMessageEnd()
3425 
    return
3426 
 
7190 amar.kumar 3427 
  def getFreebieForItem(self, itemId):
3428 
    """
3429 
    Parameters:
3430 
     - itemId
3431 
    """
3432 
    self.send_getFreebieForItem(itemId)
3433 
    return self.recv_getFreebieForItem()
6962 rajveer 3434 
 
7190 amar.kumar 3435 
  def send_getFreebieForItem(self, itemId):
3436 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3437 
    args = getFreebieForItem_args()
3438 
    args.itemId = itemId
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_getFreebieForItem(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = getFreebieForItem_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    if result.success is not None:
3454 
      return result.success
3455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3456 
 
3457 
  def addOrUpdateFreebieForItem(self, freebieItem):
3458 
    """
3459 
    Parameters:
3460 
     - freebieItem
3461 
    """
3462 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3463 
    self.recv_addOrUpdateFreebieForItem()
3464 
 
3465 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3466 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3467 
    args = addOrUpdateFreebieForItem_args()
3468 
    args.freebieItem = freebieItem
3469 
    args.write(self._oprot)
3470 
    self._oprot.writeMessageEnd()
3471 
    self._oprot.trans.flush()
3472 
 
3473 
  def recv_addOrUpdateFreebieForItem(self, ):
3474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3475 
    if mtype == TMessageType.EXCEPTION:
3476 
      x = TApplicationException()
3477 
      x.read(self._iprot)
3478 
      self._iprot.readMessageEnd()
3479 
      raise x
3480 
    result = addOrUpdateFreebieForItem_result()
3481 
    result.read(self._iprot)
3482 
    self._iprot.readMessageEnd()
3483 
    return
3484 
 
7272 amit.gupta 3485 
  def addOrUpdateBrandInfo(self, brandInfo):
3486 
    """
3487 
    Parameters:
3488 
     - brandInfo
3489 
    """
3490 
    self.send_addOrUpdateBrandInfo(brandInfo)
3491 
    self.recv_addOrUpdateBrandInfo()
3492 
 
3493 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3494 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3495 
    args = addOrUpdateBrandInfo_args()
3496 
    args.brandInfo = brandInfo
3497 
    args.write(self._oprot)
3498 
    self._oprot.writeMessageEnd()
3499 
    self._oprot.trans.flush()
3500 
 
3501 
  def recv_addOrUpdateBrandInfo(self, ):
3502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3503 
    if mtype == TMessageType.EXCEPTION:
3504 
      x = TApplicationException()
3505 
      x.read(self._iprot)
3506 
      self._iprot.readMessageEnd()
3507 
      raise x
3508 
    result = addOrUpdateBrandInfo_result()
3509 
    result.read(self._iprot)
3510 
    self._iprot.readMessageEnd()
3511 
    return
3512 
 
3513 
  def getBrandInfo(self, ):
3514 
    self.send_getBrandInfo()
3515 
    return self.recv_getBrandInfo()
3516 
 
3517 
  def send_getBrandInfo(self, ):
3518 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3519 
    args = getBrandInfo_args()
3520 
    args.write(self._oprot)
3521 
    self._oprot.writeMessageEnd()
3522 
    self._oprot.trans.flush()
3523 
 
3524 
  def recv_getBrandInfo(self, ):
3525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3526 
    if mtype == TMessageType.EXCEPTION:
3527 
      x = TApplicationException()
3528 
      x.read(self._iprot)
3529 
      self._iprot.readMessageEnd()
3530 
      raise x
3531 
    result = getBrandInfo_result()
3532 
    result.read(self._iprot)
3533 
    self._iprot.readMessageEnd()
3534 
    if result.success is not None:
3535 
      return result.success
3536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3537 
 
7256 rajveer 3538 
  def getStorePricing(self, itemId):
3539 
    """
3540 
    Parameters:
3541 
     - itemId
3542 
    """
3543 
    self.send_getStorePricing(itemId)
3544 
    return self.recv_getStorePricing()
7190 amar.kumar 3545 
 
7256 rajveer 3546 
  def send_getStorePricing(self, itemId):
3547 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3548 
    args = getStorePricing_args()
3549 
    args.itemId = itemId
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_getStorePricing(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = getStorePricing_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    if result.success is not None:
3565 
      return result.success
3566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3567 
 
7306 rajveer 3568 
  def getStorePricings(self, itemIds):
3569 
    """
3570 
    Parameters:
3571 
     - itemIds
3572 
    """
3573 
    self.send_getStorePricings(itemIds)
3574 
    return self.recv_getStorePricings()
3575 
 
3576 
  def send_getStorePricings(self, itemIds):
3577 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3578 
    args = getStorePricings_args()
3579 
    args.itemIds = itemIds
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_getStorePricings(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = getStorePricings_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3594 
    if result.success is not None:
3595 
      return result.success
3596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3597 
 
7382 rajveer 3598 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3599 
    """
3600 
    Parameters:
3601 
     - sp
7382 rajveer 3602 
     - allColors
7265 rajveer 3603 
    """
7382 rajveer 3604 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3605 
    self.recv_updateStorePricing()
7256 rajveer 3606 
 
7382 rajveer 3607 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3608 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3609 
    args = updateStorePricing_args()
3610 
    args.sp = sp
7382 rajveer 3611 
    args.allColors = allColors
7265 rajveer 3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_updateStorePricing(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = updateStorePricing_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
3626 
    return
3627 
 
7281 kshitij.so 3628 
  def getAllAmazonListedItems(self, ):
3629 
    self.send_getAllAmazonListedItems()
3630 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3631 
 
7281 kshitij.so 3632 
  def send_getAllAmazonListedItems(self, ):
3633 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3634 
    args = getAllAmazonListedItems_args()
3635 
    args.write(self._oprot)
3636 
    self._oprot.writeMessageEnd()
3637 
    self._oprot.trans.flush()
3638 
 
3639 
  def recv_getAllAmazonListedItems(self, ):
3640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3641 
    if mtype == TMessageType.EXCEPTION:
3642 
      x = TApplicationException()
3643 
      x.read(self._iprot)
3644 
      self._iprot.readMessageEnd()
3645 
      raise x
3646 
    result = getAllAmazonListedItems_result()
3647 
    result.read(self._iprot)
3648 
    self._iprot.readMessageEnd()
3649 
    if result.success is not None:
3650 
      return result.success
3651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3652 
 
3653 
  def getAmazonItemDetails(self, itemId):
3654 
    """
3655 
    Parameters:
3656 
     - itemId
3657 
    """
3658 
    self.send_getAmazonItemDetails(itemId)
3659 
    return self.recv_getAmazonItemDetails()
3660 
 
3661 
  def send_getAmazonItemDetails(self, itemId):
3662 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3663 
    args = getAmazonItemDetails_args()
3664 
    args.itemId = itemId
3665 
    args.write(self._oprot)
3666 
    self._oprot.writeMessageEnd()
3667 
    self._oprot.trans.flush()
3668 
 
3669 
  def recv_getAmazonItemDetails(self, ):
3670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3671 
    if mtype == TMessageType.EXCEPTION:
3672 
      x = TApplicationException()
3673 
      x.read(self._iprot)
3674 
      self._iprot.readMessageEnd()
3675 
      raise x
3676 
    result = getAmazonItemDetails_result()
3677 
    result.read(self._iprot)
3678 
    self._iprot.readMessageEnd()
3679 
    if result.success is not None:
3680 
      return result.success
3681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3682 
 
7367 kshitij.so 3683 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3684 
    """
3685 
    Parameters:
3686 
     - itemId
3687 
     - fbaPrice
3688 
     - sellingPrice
3689 
     - isFba
3690 
     - isNonFba
3691 
     - isInventoryOverride
7367 kshitij.so 3692 
     - handlingTime
3693 
     - isCustomTime
7281 kshitij.so 3694 
    """
7367 kshitij.so 3695 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3696 
    self.recv_updateAmazonItemDetails()
3697 
 
7367 kshitij.so 3698 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3699 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3700 
    args = updateAmazonItemDetails_args()
3701 
    args.itemId = itemId
3702 
    args.fbaPrice = fbaPrice
3703 
    args.sellingPrice = sellingPrice
3704 
    args.isFba = isFba
3705 
    args.isNonFba = isNonFba
3706 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3707 
    args.handlingTime = handlingTime
3708 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3709 
    args.write(self._oprot)
3710 
    self._oprot.writeMessageEnd()
3711 
    self._oprot.trans.flush()
3712 
 
3713 
  def recv_updateAmazonItemDetails(self, ):
3714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3715 
    if mtype == TMessageType.EXCEPTION:
3716 
      x = TApplicationException()
3717 
      x.read(self._iprot)
3718 
      self._iprot.readMessageEnd()
3719 
      raise x
3720 
    result = updateAmazonItemDetails_result()
3721 
    result.read(self._iprot)
3722 
    self._iprot.readMessageEnd()
3723 
    return
3724 
 
3725 
  def addAmazonItem(self, amazonlisted):
3726 
    """
3727 
    Parameters:
3728 
     - amazonlisted
3729 
    """
3730 
    self.send_addAmazonItem(amazonlisted)
3731 
    self.recv_addAmazonItem()
3732 
 
3733 
  def send_addAmazonItem(self, amazonlisted):
3734 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3735 
    args = addAmazonItem_args()
3736 
    args.amazonlisted = amazonlisted
3737 
    args.write(self._oprot)
3738 
    self._oprot.writeMessageEnd()
3739 
    self._oprot.trans.flush()
3740 
 
3741 
  def recv_addAmazonItem(self, ):
3742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3743 
    if mtype == TMessageType.EXCEPTION:
3744 
      x = TApplicationException()
3745 
      x.read(self._iprot)
3746 
      self._iprot.readMessageEnd()
3747 
      raise x
3748 
    result = addAmazonItem_result()
3749 
    result.read(self._iprot)
3750 
    self._iprot.readMessageEnd()
3751 
    return
3752 
 
7291 vikram.rag 3753 
  def getAsinItems(self, ):
3754 
    self.send_getAsinItems()
3755 
    return self.recv_getAsinItems()
7281 kshitij.so 3756 
 
7291 vikram.rag 3757 
  def send_getAsinItems(self, ):
3758 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3759 
    args = getAsinItems_args()
3760 
    args.write(self._oprot)
3761 
    self._oprot.writeMessageEnd()
3762 
    self._oprot.trans.flush()
3763 
 
3764 
  def recv_getAsinItems(self, ):
3765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3766 
    if mtype == TMessageType.EXCEPTION:
3767 
      x = TApplicationException()
3768 
      x.read(self._iprot)
3769 
      self._iprot.readMessageEnd()
3770 
      raise x
3771 
    result = getAsinItems_result()
3772 
    result.read(self._iprot)
3773 
    self._iprot.readMessageEnd()
3774 
    if result.success is not None:
3775 
      return result.success
3776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3777 
 
3778 
  def getAllFbaListedItems(self, ):
3779 
    self.send_getAllFbaListedItems()
3780 
    return self.recv_getAllFbaListedItems()
3781 
 
3782 
  def send_getAllFbaListedItems(self, ):
3783 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3784 
    args = getAllFbaListedItems_args()
3785 
    args.write(self._oprot)
3786 
    self._oprot.writeMessageEnd()
3787 
    self._oprot.trans.flush()
3788 
 
3789 
  def recv_getAllFbaListedItems(self, ):
3790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3791 
    if mtype == TMessageType.EXCEPTION:
3792 
      x = TApplicationException()
3793 
      x.read(self._iprot)
3794 
      self._iprot.readMessageEnd()
3795 
      raise x
3796 
    result = getAllFbaListedItems_result()
3797 
    result.read(self._iprot)
3798 
    self._iprot.readMessageEnd()
3799 
    if result.success is not None:
3800 
      return result.success
3801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3802 
 
3803 
  def getAllNonFbaListedItems(self, ):
3804 
    self.send_getAllNonFbaListedItems()
3805 
    return self.recv_getAllNonFbaListedItems()
3806 
 
3807 
  def send_getAllNonFbaListedItems(self, ):
3808 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3809 
    args = getAllNonFbaListedItems_args()
3810 
    args.write(self._oprot)
3811 
    self._oprot.writeMessageEnd()
3812 
    self._oprot.trans.flush()
3813 
 
3814 
  def recv_getAllNonFbaListedItems(self, ):
3815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3816 
    if mtype == TMessageType.EXCEPTION:
3817 
      x = TApplicationException()
3818 
      x.read(self._iprot)
3819 
      self._iprot.readMessageEnd()
3820 
      raise x
3821 
    result = getAllNonFbaListedItems_result()
3822 
    result.read(self._iprot)
3823 
    self._iprot.readMessageEnd()
3824 
    if result.success is not None:
3825 
      return result.success
3826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3827 
 
7460 kshitij.so 3828 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3829 
    """
3830 
    Parameters:
3831 
     - itemId
3832 
     - holdInventory
3833 
     - defaultInventory
3834 
    """
3835 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3836 
    return self.recv_updateItemInventory()
7291 vikram.rag 3837 
 
7460 kshitij.so 3838 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3839 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3840 
    args = updateItemInventory_args()
3841 
    args.itemId = itemId
3842 
    args.holdInventory = holdInventory
3843 
    args.defaultInventory = defaultInventory
3844 
    args.write(self._oprot)
3845 
    self._oprot.writeMessageEnd()
3846 
    self._oprot.trans.flush()
3847 
 
3848 
  def recv_updateItemInventory(self, ):
3849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3850 
    if mtype == TMessageType.EXCEPTION:
3851 
      x = TApplicationException()
3852 
      x.read(self._iprot)
3853 
      self._iprot.readMessageEnd()
3854 
      raise x
3855 
    result = updateItemInventory_result()
3856 
    result.read(self._iprot)
3857 
    self._iprot.readMessageEnd()
3858 
    if result.success is not None:
3859 
      return result.success
3860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3861 
 
7770 kshitij.so 3862 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3863 
    """
3864 
    Parameters:
3865 
     - type
3866 
     - sku
3867 
     - timestamp
3868 
    """
3869 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3870 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3871 
 
7770 kshitij.so 3872 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3873 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3874 
    args = updateTimestampForAmazonFeeds_args()
3875 
    args.type = type
3876 
    args.sku = sku
3877 
    args.timestamp = timestamp
3878 
    args.write(self._oprot)
3879 
    self._oprot.writeMessageEnd()
3880 
    self._oprot.trans.flush()
3881 
 
3882 
  def recv_updateTimestampForAmazonFeeds(self, ):
3883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3884 
    if mtype == TMessageType.EXCEPTION:
3885 
      x = TApplicationException()
3886 
      x.read(self._iprot)
3887 
      self._iprot.readMessageEnd()
3888 
      raise x
3889 
    result = updateTimestampForAmazonFeeds_result()
3890 
    result.read(self._iprot)
3891 
    self._iprot.readMessageEnd()
3892 
    if result.success is not None:
3893 
      return result.success
3894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3895 
 
3896 
 
5944 mandeep.dh 3897 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3898 
  def __init__(self, handler):
3899 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3900 
    self._processMap["addItem"] = Processor.process_addItem
3901 
    self._processMap["updateItem"] = Processor.process_updateItem
3902 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 3903 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 3904 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3905 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3906 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3907 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3908 
    self._processMap["getItem"] = Processor.process_getItem
3909 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3910 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3911 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3912 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3913 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3914 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3915 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3916 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3917 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3918 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3919 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3920 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3921 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3922 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3923 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3924 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3925 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3926 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3927 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3928 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3929 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3930 
    self._processMap["addCategory"] = Processor.process_addCategory
3931 
    self._processMap["getCategory"] = Processor.process_getCategory
3932 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3933 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3934 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3935 
    self._processMap["addTag"] = Processor.process_addTag
3936 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3937 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3938 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3939 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3940 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3941 
    self._processMap["addBanner"] = Processor.process_addBanner
3942 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3943 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3944 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3945 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3946 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3947 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3948 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3949 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3950 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3951 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3952 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3953 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3954 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3955 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3956 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3957 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3958 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3959 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3960 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3961 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3962 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3963 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3964 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3965 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3966 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3967 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3968 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3969 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3970 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3971 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3972 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3973 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3974 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3975 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3976 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3977 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3978 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3979 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3980 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3981 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3982 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3983 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3984 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3985 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3986 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3987 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3988 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3989 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3990 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3991 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3992 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3993 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3994 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3995 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3996 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 3997 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 3998 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
5944 mandeep.dh 3999 
 
4000 
  def process(self, iprot, oprot):
4001 
    (name, type, seqid) = iprot.readMessageBegin()
4002 
    if name not in self._processMap:
4003 
      iprot.skip(TType.STRUCT)
4004 
      iprot.readMessageEnd()
4005 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4006 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4007 
      x.write(oprot)
4008 
      oprot.writeMessageEnd()
4009 
      oprot.trans.flush()
4010 
      return
4011 
    else:
4012 
      self._processMap[name](self, seqid, iprot, oprot)
4013 
    return True
4014 
 
4015 
  def process_addItem(self, seqid, iprot, oprot):
4016 
    args = addItem_args()
4017 
    args.read(iprot)
4018 
    iprot.readMessageEnd()
4019 
    result = addItem_result()
4020 
    try:
4021 
      result.success = self._handler.addItem(args.item)
4022 
    except CatalogServiceException, cex:
4023 
      result.cex = cex
4024 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4025 
    result.write(oprot)
4026 
    oprot.writeMessageEnd()
4027 
    oprot.trans.flush()
4028 
 
4029 
  def process_updateItem(self, seqid, iprot, oprot):
4030 
    args = updateItem_args()
4031 
    args.read(iprot)
4032 
    iprot.readMessageEnd()
4033 
    result = updateItem_result()
4034 
    try:
4035 
      result.success = self._handler.updateItem(args.item)
4036 
    except CatalogServiceException, cex:
4037 
      result.cex = cex
4038 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4039 
    result.write(oprot)
4040 
    oprot.writeMessageEnd()
4041 
    oprot.trans.flush()
4042 
 
4043 
  def process_isActive(self, seqid, iprot, oprot):
4044 
    args = isActive_args()
4045 
    args.read(iprot)
4046 
    iprot.readMessageEnd()
4047 
    result = isActive_result()
4048 
    try:
4049 
      result.success = self._handler.isActive(args.itemId)
4050 
    except CatalogServiceException, isex:
4051 
      result.isex = isex
4052 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4053 
    result.write(oprot)
4054 
    oprot.writeMessageEnd()
4055 
    oprot.trans.flush()
4056 
 
7438 amit.gupta 4057 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4058 
    args = getItemsStatus_args()
4059 
    args.read(iprot)
4060 
    iprot.readMessageEnd()
4061 
    result = getItemsStatus_result()
4062 
    try:
4063 
      result.success = self._handler.getItemsStatus(args.itemIds)
4064 
    except CatalogServiceException, isex:
4065 
      result.isex = isex
4066 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4067 
    result.write(oprot)
4068 
    oprot.writeMessageEnd()
4069 
    oprot.trans.flush()
4070 
 
5944 mandeep.dh 4071 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4072 
    args = getItemStatusDescription_args()
4073 
    args.read(iprot)
4074 
    iprot.readMessageEnd()
4075 
    result = getItemStatusDescription_result()
4076 
    try:
4077 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4078 
    except CatalogServiceException, isex:
4079 
      result.isex = isex
4080 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4081 
    result.write(oprot)
4082 
    oprot.writeMessageEnd()
4083 
    oprot.trans.flush()
4084 
 
4085 
  def process_startItemOn(self, seqid, iprot, oprot):
4086 
    args = startItemOn_args()
4087 
    args.read(iprot)
4088 
    iprot.readMessageEnd()
4089 
    result = startItemOn_result()
4090 
    try:
4091 
      self._handler.startItemOn(args.item_id, args.timestamp)
4092 
    except CatalogServiceException, cex:
4093 
      result.cex = cex
4094 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4095 
    result.write(oprot)
4096 
    oprot.writeMessageEnd()
4097 
    oprot.trans.flush()
4098 
 
4099 
  def process_retireItemOn(self, seqid, iprot, oprot):
4100 
    args = retireItemOn_args()
4101 
    args.read(iprot)
4102 
    iprot.readMessageEnd()
4103 
    result = retireItemOn_result()
4104 
    try:
4105 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4106 
    except CatalogServiceException, cex:
4107 
      result.cex = cex
4108 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4109 
    result.write(oprot)
4110 
    oprot.writeMessageEnd()
4111 
    oprot.trans.flush()
4112 
 
4113 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4114 
    args = changeItemStatus_args()
4115 
    args.read(iprot)
4116 
    iprot.readMessageEnd()
4117 
    result = changeItemStatus_result()
4118 
    try:
4119 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4120 
    except CatalogServiceException, cex:
4121 
      result.cex = cex
4122 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4123 
    result.write(oprot)
4124 
    oprot.writeMessageEnd()
4125 
    oprot.trans.flush()
4126 
 
4127 
  def process_getItem(self, seqid, iprot, oprot):
4128 
    args = getItem_args()
4129 
    args.read(iprot)
4130 
    iprot.readMessageEnd()
4131 
    result = getItem_result()
4132 
    try:
4133 
      result.success = self._handler.getItem(args.item_id)
4134 
    except CatalogServiceException, cex:
4135 
      result.cex = cex
4136 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4137 
    result.write(oprot)
4138 
    oprot.writeMessageEnd()
4139 
    oprot.trans.flush()
4140 
 
4141 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4142 
    args = getItemsByCatalogId_args()
4143 
    args.read(iprot)
4144 
    iprot.readMessageEnd()
4145 
    result = getItemsByCatalogId_result()
4146 
    try:
4147 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4148 
    except CatalogServiceException, cex:
4149 
      result.cex = cex
4150 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
4154 
 
4155 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4156 
    args = getValidItemsByCatalogId_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = getValidItemsByCatalogId_result()
4160 
    try:
4161 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4162 
    except CatalogServiceException, cex:
4163 
      result.cex = cex
4164 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
4169 
  def process_getAllItems(self, seqid, iprot, oprot):
4170 
    args = getAllItems_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = getAllItems_result()
4174 
    try:
4175 
      result.success = self._handler.getAllItems(args.isActive)
4176 
    except CatalogServiceException, cex:
4177 
      result.cex = cex
4178 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
4183 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4184 
    args = getAllItemsByStatus_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = getAllItemsByStatus_result()
4188 
    try:
4189 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4190 
    except CatalogServiceException, cex:
4191 
      result.cex = cex
4192 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
4197 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4198 
    args = markItemAsContentComplete_args()
4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4201 
    result = markItemAsContentComplete_result()
4202 
    try:
4203 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4204 
    except CatalogServiceException, cex:
4205 
      result.cex = cex
4206 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
4210 
 
4211 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4212 
    args = getAllItemsInRange_args()
4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
4215 
    result = getAllItemsInRange_result()
4216 
    try:
4217 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4218 
    except CatalogServiceException, cex:
4219 
      result.cex = cex
4220 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
4224 
 
4225 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4226 
    args = getAllItemsByStatusInRange_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = getAllItemsByStatusInRange_result()
4230 
    try:
4231 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4232 
    except CatalogServiceException, cex:
4233 
      result.cex = cex
4234 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4239 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4240 
    args = getItemCountByStatus_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getItemCountByStatus_result()
4244 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4245 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4246 
    result.write(oprot)
4247 
    oprot.writeMessageEnd()
4248 
    oprot.trans.flush()
4249 
 
4250 
  def process_getBestSellers(self, seqid, iprot, oprot):
4251 
    args = getBestSellers_args()
4252 
    args.read(iprot)
4253 
    iprot.readMessageEnd()
4254 
    result = getBestSellers_result()
4255 
    try:
4256 
      result.success = self._handler.getBestSellers()
4257 
    except CatalogServiceException, isex:
4258 
      result.isex = isex
4259 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4260 
    result.write(oprot)
4261 
    oprot.writeMessageEnd()
4262 
    oprot.trans.flush()
4263 
 
4264 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4265 
    args = getBestSellersCatalogIds_args()
4266 
    args.read(iprot)
4267 
    iprot.readMessageEnd()
4268 
    result = getBestSellersCatalogIds_result()
4269 
    try:
4270 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4271 
    except CatalogServiceException, cex:
4272 
      result.cex = cex
4273 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
4277 
 
4278 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4279 
    args = getBestSellersCount_args()
4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
4282 
    result = getBestSellersCount_result()
4283 
    try:
4284 
      result.success = self._handler.getBestSellersCount()
4285 
    except CatalogServiceException, cex:
4286 
      result.cex = cex
4287 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4288 
    result.write(oprot)
4289 
    oprot.writeMessageEnd()
4290 
    oprot.trans.flush()
4291 
 
4292 
  def process_getBestDeals(self, seqid, iprot, oprot):
4293 
    args = getBestDeals_args()
4294 
    args.read(iprot)
4295 
    iprot.readMessageEnd()
4296 
    result = getBestDeals_result()
4297 
    try:
4298 
      result.success = self._handler.getBestDeals()
4299 
    except CatalogServiceException, isex:
4300 
      result.isex = isex
4301 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4302 
    result.write(oprot)
4303 
    oprot.writeMessageEnd()
4304 
    oprot.trans.flush()
4305 
 
4306 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4307 
    args = getBestDealsCatalogIds_args()
4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
4310 
    result = getBestDealsCatalogIds_result()
4311 
    try:
4312 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4313 
    except CatalogServiceException, cex:
4314 
      result.cex = cex
4315 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
4319 
 
4320 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4321 
    args = getBestDealsCount_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = getBestDealsCount_result()
4325 
    try:
4326 
      result.success = self._handler.getBestDealsCount()
4327 
    except CatalogServiceException, cex:
4328 
      result.cex = cex
4329 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4330 
    result.write(oprot)
4331 
    oprot.writeMessageEnd()
4332 
    oprot.trans.flush()
4333 
 
4334 
  def process_getComingSoon(self, seqid, iprot, oprot):
4335 
    args = getComingSoon_args()
4336 
    args.read(iprot)
4337 
    iprot.readMessageEnd()
4338 
    result = getComingSoon_result()
4339 
    try:
4340 
      result.success = self._handler.getComingSoon()
4341 
    except CatalogServiceException, isex:
4342 
      result.isex = isex
4343 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4344 
    result.write(oprot)
4345 
    oprot.writeMessageEnd()
4346 
    oprot.trans.flush()
4347 
 
4348 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4349 
    args = getComingSoonCatalogIds_args()
4350 
    args.read(iprot)
4351 
    iprot.readMessageEnd()
4352 
    result = getComingSoonCatalogIds_result()
4353 
    try:
4354 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4355 
    except CatalogServiceException, cex:
4356 
      result.cex = cex
4357 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4358 
    result.write(oprot)
4359 
    oprot.writeMessageEnd()
4360 
    oprot.trans.flush()
4361 
 
4362 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4363 
    args = getComingSoonCount_args()
4364 
    args.read(iprot)
4365 
    iprot.readMessageEnd()
4366 
    result = getComingSoonCount_result()
4367 
    try:
4368 
      result.success = self._handler.getComingSoonCount()
4369 
    except CatalogServiceException, cex:
4370 
      result.cex = cex
4371 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4372 
    result.write(oprot)
4373 
    oprot.writeMessageEnd()
4374 
    oprot.trans.flush()
4375 
 
4376 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4377 
    args = getLatestArrivals_args()
4378 
    args.read(iprot)
4379 
    iprot.readMessageEnd()
4380 
    result = getLatestArrivals_result()
4381 
    try:
4382 
      result.success = self._handler.getLatestArrivals()
4383 
    except CatalogServiceException, isex:
4384 
      result.isex = isex
4385 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4386 
    result.write(oprot)
4387 
    oprot.writeMessageEnd()
4388 
    oprot.trans.flush()
4389 
 
4390 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4391 
    args = getLatestArrivalsCatalogIds_args()
4392 
    args.read(iprot)
4393 
    iprot.readMessageEnd()
4394 
    result = getLatestArrivalsCatalogIds_result()
4395 
    try:
4396 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4397 
    except CatalogServiceException, cex:
4398 
      result.cex = cex
4399 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4400 
    result.write(oprot)
4401 
    oprot.writeMessageEnd()
4402 
    oprot.trans.flush()
4403 
 
4404 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4405 
    args = getLatestArrivalsCount_args()
4406 
    args.read(iprot)
4407 
    iprot.readMessageEnd()
4408 
    result = getLatestArrivalsCount_result()
4409 
    try:
4410 
      result.success = self._handler.getLatestArrivalsCount()
4411 
    except CatalogServiceException, cex:
4412 
      result.cex = cex
4413 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4414 
    result.write(oprot)
4415 
    oprot.writeMessageEnd()
4416 
    oprot.trans.flush()
4417 
 
4418 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4419 
    args = generateNewEntityID_args()
4420 
    args.read(iprot)
4421 
    iprot.readMessageEnd()
4422 
    result = generateNewEntityID_result()
4423 
    result.success = self._handler.generateNewEntityID()
4424 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
4429 
  def process_addCategory(self, seqid, iprot, oprot):
4430 
    args = addCategory_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = addCategory_result()
4434 
    result.success = self._handler.addCategory(args.category)
4435 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4436 
    result.write(oprot)
4437 
    oprot.writeMessageEnd()
4438 
    oprot.trans.flush()
4439 
 
4440 
  def process_getCategory(self, seqid, iprot, oprot):
4441 
    args = getCategory_args()
4442 
    args.read(iprot)
4443 
    iprot.readMessageEnd()
4444 
    result = getCategory_result()
4445 
    result.success = self._handler.getCategory(args.id)
4446 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
4450 
 
4451 
  def process_getAllCategories(self, seqid, iprot, oprot):
4452 
    args = getAllCategories_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = getAllCategories_result()
4456 
    result.success = self._handler.getAllCategories()
4457 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4458 
    result.write(oprot)
4459 
    oprot.writeMessageEnd()
4460 
    oprot.trans.flush()
4461 
 
4462 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4463 
    args = getAllSimilarItems_args()
4464 
    args.read(iprot)
4465 
    iprot.readMessageEnd()
4466 
    result = getAllSimilarItems_result()
4467 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4468 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4469 
    result.write(oprot)
4470 
    oprot.writeMessageEnd()
4471 
    oprot.trans.flush()
4472 
 
4473 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4474 
    args = addSimilarItem_args()
4475 
    args.read(iprot)
4476 
    iprot.readMessageEnd()
4477 
    result = addSimilarItem_result()
4478 
    try:
4479 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4480 
    except CatalogServiceException, cex:
4481 
      result.cex = cex
4482 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4483 
    result.write(oprot)
4484 
    oprot.writeMessageEnd()
4485 
    oprot.trans.flush()
4486 
 
6512 kshitij.so 4487 
  def process_addTag(self, seqid, iprot, oprot):
4488 
    args = addTag_args()
4489 
    args.read(iprot)
4490 
    iprot.readMessageEnd()
4491 
    result = addTag_result()
4492 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4493 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4494 
    result.write(oprot)
4495 
    oprot.writeMessageEnd()
4496 
    oprot.trans.flush()
4497 
 
4498 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4499 
    args = deleteEntityTag_args()
4500 
    args.read(iprot)
4501 
    iprot.readMessageEnd()
4502 
    result = deleteEntityTag_result()
4503 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4504 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4505 
    result.write(oprot)
4506 
    oprot.writeMessageEnd()
4507 
    oprot.trans.flush()
4508 
 
4509 
  def process_deleteTag(self, seqid, iprot, oprot):
4510 
    args = deleteTag_args()
4511 
    args.read(iprot)
4512 
    iprot.readMessageEnd()
4513 
    result = deleteTag_result()
4514 
    result.success = self._handler.deleteTag(args.displayName)
4515 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4516 
    result.write(oprot)
4517 
    oprot.writeMessageEnd()
4518 
    oprot.trans.flush()
4519 
 
4520 
  def process_getAllTags(self, seqid, iprot, oprot):
4521 
    args = getAllTags_args()
4522 
    args.read(iprot)
4523 
    iprot.readMessageEnd()
4524 
    result = getAllTags_result()
4525 
    result.success = self._handler.getAllTags()
4526 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
4531 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4532 
    args = getAllEntitiesByTagName_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = getAllEntitiesByTagName_result()
4536 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4537 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4538 
    result.write(oprot)
4539 
    oprot.writeMessageEnd()
4540 
    oprot.trans.flush()
4541 
 
6845 amit.gupta 4542 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4543 
    args = getAllEntityTags_args()
4544 
    args.read(iprot)
4545 
    iprot.readMessageEnd()
4546 
    result = getAllEntityTags_result()
4547 
    result.success = self._handler.getAllEntityTags()
4548 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4549 
    result.write(oprot)
4550 
    oprot.writeMessageEnd()
4551 
    oprot.trans.flush()
4552 
 
6850 kshitij.so 4553 
  def process_addBanner(self, seqid, iprot, oprot):
4554 
    args = addBanner_args()
4555 
    args.read(iprot)
4556 
    iprot.readMessageEnd()
4557 
    result = addBanner_result()
4558 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4559 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4560 
    result.write(oprot)
4561 
    oprot.writeMessageEnd()
4562 
    oprot.trans.flush()
4563 
 
4564 
  def process_getAllBanners(self, seqid, iprot, oprot):
4565 
    args = getAllBanners_args()
4566 
    args.read(iprot)
4567 
    iprot.readMessageEnd()
4568 
    result = getAllBanners_result()
4569 
    result.success = self._handler.getAllBanners()
4570 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4571 
    result.write(oprot)
4572 
    oprot.writeMessageEnd()
4573 
    oprot.trans.flush()
4574 
 
4575 
  def process_deleteBanner(self, seqid, iprot, oprot):
4576 
    args = deleteBanner_args()
4577 
    args.read(iprot)
4578 
    iprot.readMessageEnd()
4579 
    result = deleteBanner_result()
4580 
    result.success = self._handler.deleteBanner(args.bannerName)
4581 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
4586 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4587 
    args = getBannerDetails_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = getBannerDetails_result()
4591 
    result.success = self._handler.getBannerDetails(args.bannerName)
4592 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4593 
    result.write(oprot)
4594 
    oprot.writeMessageEnd()
4595 
    oprot.trans.flush()
4596 
 
4597 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4598 
    args = getActiveBanners_args()
4599 
    args.read(iprot)
4600 
    iprot.readMessageEnd()
4601 
    result = getActiveBanners_result()
4602 
    result.success = self._handler.getActiveBanners()
4603 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
6849 kshitij.so 4608 
  def process_addBannerMap(self, seqid, iprot, oprot):
4609 
    args = addBannerMap_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = addBannerMap_result()
4613 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4614 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4615 
    result.write(oprot)
4616 
    oprot.writeMessageEnd()
4617 
    oprot.trans.flush()
4618 
 
4619 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4620 
    args = deleteBannerMap_args()
4621 
    args.read(iprot)
4622 
    iprot.readMessageEnd()
4623 
    result = deleteBannerMap_result()
4624 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4625 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4626 
    result.write(oprot)
4627 
    oprot.writeMessageEnd()
4628 
    oprot.trans.flush()
4629 
 
4630 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4631 
    args = getBannerMapDetails_args()
4632 
    args.read(iprot)
4633 
    iprot.readMessageEnd()
4634 
    result = getBannerMapDetails_result()
4635 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4636 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4637 
    result.write(oprot)
4638 
    oprot.writeMessageEnd()
4639 
    oprot.trans.flush()
4640 
 
5944 mandeep.dh 4641 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4642 
    args = deleteSimilarItem_args()
4643 
    args.read(iprot)
4644 
    iprot.readMessageEnd()
4645 
    result = deleteSimilarItem_result()
4646 
    try:
4647 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4648 
    except CatalogServiceException, cex:
4649 
      result.cex = cex
4650 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
4655 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4656 
    args = checkSimilarItem_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = checkSimilarItem_result()
4660 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4661 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
4666 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4667 
    args = validateRiskyStatus_args()
4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
4670 
    result = validateRiskyStatus_result()
4671 
    self._handler.validateRiskyStatus(args.itemId)
4672 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4673 
    result.write(oprot)
4674 
    oprot.writeMessageEnd()
4675 
    oprot.trans.flush()
4676 
 
4677 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4678 
    args = changeItemRiskyFlag_args()
4679 
    args.read(iprot)
4680 
    iprot.readMessageEnd()
4681 
    result = changeItemRiskyFlag_result()
4682 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4683 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4684 
    result.write(oprot)
4685 
    oprot.writeMessageEnd()
4686 
    oprot.trans.flush()
4687 
 
4688 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4689 
    args = getItemsByRiskyFlag_args()
4690 
    args.read(iprot)
4691 
    iprot.readMessageEnd()
4692 
    result = getItemsByRiskyFlag_result()
4693 
    result.success = self._handler.getItemsByRiskyFlag()
4694 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4695 
    result.write(oprot)
4696 
    oprot.writeMessageEnd()
4697 
    oprot.trans.flush()
4698 
 
4699 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4700 
    args = getItemsForMasterSheet_args()
4701 
    args.read(iprot)
4702 
    iprot.readMessageEnd()
4703 
    result = getItemsForMasterSheet_result()
4704 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4705 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4706 
    result.write(oprot)
4707 
    oprot.writeMessageEnd()
4708 
    oprot.trans.flush()
4709 
 
4710 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4711 
    args = getSimilarItemsCatalogIds_args()
4712 
    args.read(iprot)
4713 
    iprot.readMessageEnd()
4714 
    result = getSimilarItemsCatalogIds_result()
4715 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4716 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4717 
    result.write(oprot)
4718 
    oprot.writeMessageEnd()
4719 
    oprot.trans.flush()
4720 
 
4721 
  def process_addProductNotification(self, seqid, iprot, oprot):
4722 
    args = addProductNotification_args()
4723 
    args.read(iprot)
4724 
    iprot.readMessageEnd()
4725 
    result = addProductNotification_result()
4726 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4727 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4728 
    result.write(oprot)
4729 
    oprot.writeMessageEnd()
4730 
    oprot.trans.flush()
4731 
 
4732 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4733 
    args = sendProductNotifications_args()
4734 
    args.read(iprot)
4735 
    iprot.readMessageEnd()
4736 
    result = sendProductNotifications_result()
4737 
    result.success = self._handler.sendProductNotifications()
4738 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4739 
    result.write(oprot)
4740 
    oprot.writeMessageEnd()
4741 
    oprot.trans.flush()
4742 
 
4743 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4744 
    args = getAllBrandsByCategory_args()
4745 
    args.read(iprot)
4746 
    iprot.readMessageEnd()
4747 
    result = getAllBrandsByCategory_result()
4748 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4749 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4750 
    result.write(oprot)
4751 
    oprot.writeMessageEnd()
4752 
    oprot.trans.flush()
4753 
 
4754 
  def process_getAllBrands(self, seqid, iprot, oprot):
4755 
    args = getAllBrands_args()
4756 
    args.read(iprot)
4757 
    iprot.readMessageEnd()
4758 
    result = getAllBrands_result()
4759 
    result.success = self._handler.getAllBrands()
4760 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4761 
    result.write(oprot)
4762 
    oprot.writeMessageEnd()
4763 
    oprot.trans.flush()
4764 
 
4765 
  def process_getAllSources(self, seqid, iprot, oprot):
4766 
    args = getAllSources_args()
4767 
    args.read(iprot)
4768 
    iprot.readMessageEnd()
4769 
    result = getAllSources_result()
4770 
    result.success = self._handler.getAllSources()
4771 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
4776 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4777 
    args = getItemPricingBySource_args()
4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
4780 
    result = getItemPricingBySource_result()
4781 
    try:
4782 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4783 
    except CatalogServiceException, cex:
4784 
      result.cex = cex
4785 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
4790 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4791 
    args = addSourceItemPricing_args()
4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
4794 
    result = addSourceItemPricing_result()
4795 
    try:
4796 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4797 
    except CatalogServiceException, cex:
4798 
      result.cex = cex
4799 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
4803 
 
4804 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4805 
    args = getAllSourcePricing_args()
4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
4808 
    result = getAllSourcePricing_result()
4809 
    try:
4810 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4811 
    except CatalogServiceException, cex:
4812 
      result.cex = cex
4813 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
4818 
  def process_getItemForSource(self, seqid, iprot, oprot):
4819 
    args = getItemForSource_args()
4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
4822 
    result = getItemForSource_result()
4823 
    try:
4824 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4825 
    except CatalogServiceException, cex:
4826 
      result.cex = cex
4827 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
4832 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4833 
    args = searchItemsInRange_args()
4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
4836 
    result = searchItemsInRange_result()
4837 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4838 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4839 
    result.write(oprot)
4840 
    oprot.writeMessageEnd()
4841 
    oprot.trans.flush()
4842 
 
4843 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4844 
    args = getSearchResultCount_args()
4845 
    args.read(iprot)
4846 
    iprot.readMessageEnd()
4847 
    result = getSearchResultCount_result()
4848 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4849 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4850 
    result.write(oprot)
4851 
    oprot.writeMessageEnd()
4852 
    oprot.trans.flush()
4853 
 
4854 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4855 
    args = getProductNotifications_args()
4856 
    args.read(iprot)
4857 
    iprot.readMessageEnd()
4858 
    result = getProductNotifications_result()
4859 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4860 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4861 
    result.write(oprot)
4862 
    oprot.writeMessageEnd()
4863 
    oprot.trans.flush()
4864 
 
4865 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4866 
    args = getProductNotificationRequestCount_args()
4867 
    args.read(iprot)
4868 
    iprot.readMessageEnd()
4869 
    result = getProductNotificationRequestCount_result()
4870 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4871 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4872 
    result.write(oprot)
4873 
    oprot.writeMessageEnd()
4874 
    oprot.trans.flush()
4875 
 
4876 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4877 
    args = addAuthorizationLog_args()
4878 
    args.read(iprot)
4879 
    iprot.readMessageEnd()
4880 
    result = addAuthorizationLog_result()
4881 
    try:
4882 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4883 
    except CatalogServiceException, cex:
4884 
      result.cex = cex
4885 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4886 
    result.write(oprot)
4887 
    oprot.writeMessageEnd()
4888 
    oprot.trans.flush()
4889 
 
4890 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4891 
    args = addupdateVoucherForItem_args()
4892 
    args.read(iprot)
4893 
    iprot.readMessageEnd()
4894 
    result = addupdateVoucherForItem_result()
4895 
    try:
4896 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4897 
    except CatalogServiceException, cex:
4898 
      result.cex = cex
4899 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4900 
    result.write(oprot)
4901 
    oprot.writeMessageEnd()
4902 
    oprot.trans.flush()
4903 
 
4904 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4905 
    args = deleteVoucherForItem_args()
4906 
    args.read(iprot)
4907 
    iprot.readMessageEnd()
4908 
    result = deleteVoucherForItem_result()
4909 
    try:
4910 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4911 
    except CatalogServiceException, cex:
4912 
      result.cex = cex
4913 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4914 
    result.write(oprot)
4915 
    oprot.writeMessageEnd()
4916 
    oprot.trans.flush()
4917 
 
4918 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4919 
    args = getVoucherAmount_args()
4920 
    args.read(iprot)
4921 
    iprot.readMessageEnd()
4922 
    result = getVoucherAmount_result()
4923 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4924 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4925 
    result.write(oprot)
4926 
    oprot.writeMessageEnd()
4927 
    oprot.trans.flush()
4928 
 
4929 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4930 
    args = getAllItemVouchers_args()
4931 
    args.read(iprot)
4932 
    iprot.readMessageEnd()
4933 
    result = getAllItemVouchers_result()
4934 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4935 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4936 
    result.write(oprot)
4937 
    oprot.writeMessageEnd()
4938 
    oprot.trans.flush()
4939 
 
4940 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4941 
    args = isValidCatalogItemId_args()
4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
4944 
    result = isValidCatalogItemId_result()
4945 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4946 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4947 
    result.write(oprot)
4948 
    oprot.writeMessageEnd()
4949 
    oprot.trans.flush()
4950 
 
6039 amit.gupta 4951 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4952 
    args = getVatPercentageForItem_args()
4953 
    args.read(iprot)
4954 
    iprot.readMessageEnd()
4955 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4956 
    try:
4957 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4958 
    except CatalogServiceException, cex:
4959 
      result.cex = cex
6039 amit.gupta 4960 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
5944 mandeep.dh 4964 
 
6039 amit.gupta 4965 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4966 
    args = getVatAmountForItem_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = getVatAmountForItem_result()
4970 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4971 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4975 
 
6531 vikram.rag 4976 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4977 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
4980 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4981 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4982 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
6039 amit.gupta 4986 
 
6821 amar.kumar 4987 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4988 
    args = getAllAliveItems_args()
4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
4991 
    result = getAllAliveItems_result()
4992 
    result.success = self._handler.getAllAliveItems()
4993 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4994 
    result.write(oprot)
4995 
    oprot.writeMessageEnd()
4996 
    oprot.trans.flush()
4997 
 
6805 anupam.sin 4998 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4999 
    args = getInsuranceAmount_args()
5000 
    args.read(iprot)
5001 
    iprot.readMessageEnd()
5002 
    result = getInsuranceAmount_result()
6921 anupam.sin 5003 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5004 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5005 
    result.write(oprot)
5006 
    oprot.writeMessageEnd()
5007 
    oprot.trans.flush()
6531 vikram.rag 5008 
 
6805 anupam.sin 5009 
  def process_getInsurer(self, seqid, iprot, oprot):
5010 
    args = getInsurer_args()
5011 
    args.read(iprot)
5012 
    iprot.readMessageEnd()
5013 
    result = getInsurer_result()
5014 
    result.success = self._handler.getInsurer(args.insurerId)
5015 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5016 
    result.write(oprot)
5017 
    oprot.writeMessageEnd()
5018 
    oprot.trans.flush()
5019 
 
6838 vikram.rag 5020 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5021 
    args = getAllInsurers_args()
5022 
    args.read(iprot)
5023 
    iprot.readMessageEnd()
5024 
    result = getAllInsurers_result()
5025 
    result.success = self._handler.getAllInsurers()
5026 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5027 
    result.write(oprot)
5028 
    oprot.writeMessageEnd()
5029 
    oprot.trans.flush()
6805 anupam.sin 5030 
 
6962 rajveer 5031 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5032 
    args = updateInsuranceDeclaredAmount_args()
5033 
    args.read(iprot)
5034 
    iprot.readMessageEnd()
5035 
    result = updateInsuranceDeclaredAmount_result()
5036 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5037 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5038 
    result.write(oprot)
5039 
    oprot.writeMessageEnd()
5040 
    oprot.trans.flush()
6838 vikram.rag 5041 
 
7190 amar.kumar 5042 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5043 
    args = getFreebieForItem_args()
5044 
    args.read(iprot)
5045 
    iprot.readMessageEnd()
5046 
    result = getFreebieForItem_result()
5047 
    result.success = self._handler.getFreebieForItem(args.itemId)
5048 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5049 
    result.write(oprot)
5050 
    oprot.writeMessageEnd()
5051 
    oprot.trans.flush()
6962 rajveer 5052 
 
7190 amar.kumar 5053 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5054 
    args = addOrUpdateFreebieForItem_args()
5055 
    args.read(iprot)
5056 
    iprot.readMessageEnd()
5057 
    result = addOrUpdateFreebieForItem_result()
5058 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5059 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
5063 
 
7272 amit.gupta 5064 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5065 
    args = addOrUpdateBrandInfo_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = addOrUpdateBrandInfo_result()
5069 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5070 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
5075 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5076 
    args = getBrandInfo_args()
5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
5079 
    result = getBrandInfo_result()
5080 
    result.success = self._handler.getBrandInfo()
5081 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5082 
    result.write(oprot)
5083 
    oprot.writeMessageEnd()
5084 
    oprot.trans.flush()
5085 
 
7256 rajveer 5086 
  def process_getStorePricing(self, seqid, iprot, oprot):
5087 
    args = getStorePricing_args()
5088 
    args.read(iprot)
5089 
    iprot.readMessageEnd()
5090 
    result = getStorePricing_result()
5091 
    result.success = self._handler.getStorePricing(args.itemId)
5092 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5093 
    result.write(oprot)
5094 
    oprot.writeMessageEnd()
5095 
    oprot.trans.flush()
7190 amar.kumar 5096 
 
7306 rajveer 5097 
  def process_getStorePricings(self, seqid, iprot, oprot):
5098 
    args = getStorePricings_args()
5099 
    args.read(iprot)
5100 
    iprot.readMessageEnd()
5101 
    result = getStorePricings_result()
5102 
    result.success = self._handler.getStorePricings(args.itemIds)
5103 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
5107 
 
7265 rajveer 5108 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5109 
    args = updateStorePricing_args()
5110 
    args.read(iprot)
5111 
    iprot.readMessageEnd()
5112 
    result = updateStorePricing_result()
7382 rajveer 5113 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5114 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
7256 rajveer 5118 
 
7281 kshitij.so 5119 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5120 
    args = getAllAmazonListedItems_args()
5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
5123 
    result = getAllAmazonListedItems_result()
5124 
    result.success = self._handler.getAllAmazonListedItems()
5125 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
7265 rajveer 5129 
 
7281 kshitij.so 5130 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5131 
    args = getAmazonItemDetails_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = getAmazonItemDetails_result()
5135 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5136 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5137 
    result.write(oprot)
5138 
    oprot.writeMessageEnd()
5139 
    oprot.trans.flush()
5140 
 
5141 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5142 
    args = updateAmazonItemDetails_args()
5143 
    args.read(iprot)
5144 
    iprot.readMessageEnd()
5145 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5146 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5147 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
5152 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5153 
    args = addAmazonItem_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = addAmazonItem_result()
5157 
    self._handler.addAmazonItem(args.amazonlisted)
5158 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5159 
    result.write(oprot)
5160 
    oprot.writeMessageEnd()
5161 
    oprot.trans.flush()
5162 
 
7291 vikram.rag 5163 
  def process_getAsinItems(self, seqid, iprot, oprot):
5164 
    args = getAsinItems_args()
5165 
    args.read(iprot)
5166 
    iprot.readMessageEnd()
5167 
    result = getAsinItems_result()
5168 
    result.success = self._handler.getAsinItems()
5169 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5170 
    result.write(oprot)
5171 
    oprot.writeMessageEnd()
5172 
    oprot.trans.flush()
7281 kshitij.so 5173 
 
7291 vikram.rag 5174 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5175 
    args = getAllFbaListedItems_args()
5176 
    args.read(iprot)
5177 
    iprot.readMessageEnd()
5178 
    result = getAllFbaListedItems_result()
5179 
    result.success = self._handler.getAllFbaListedItems()
5180 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5181 
    result.write(oprot)
5182 
    oprot.writeMessageEnd()
5183 
    oprot.trans.flush()
5184 
 
5185 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5186 
    args = getAllNonFbaListedItems_args()
5187 
    args.read(iprot)
5188 
    iprot.readMessageEnd()
5189 
    result = getAllNonFbaListedItems_result()
5190 
    result.success = self._handler.getAllNonFbaListedItems()
5191 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5192 
    result.write(oprot)
5193 
    oprot.writeMessageEnd()
5194 
    oprot.trans.flush()
5195 
 
7460 kshitij.so 5196 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5197 
    args = updateItemInventory_args()
5198 
    args.read(iprot)
5199 
    iprot.readMessageEnd()
5200 
    result = updateItemInventory_result()
5201 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5202 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5203 
    result.write(oprot)
5204 
    oprot.writeMessageEnd()
5205 
    oprot.trans.flush()
7291 vikram.rag 5206 
 
7770 kshitij.so 5207 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5208 
    args = updateTimestampForAmazonFeeds_args()
5209 
    args.read(iprot)
5210 
    iprot.readMessageEnd()
5211 
    result = updateTimestampForAmazonFeeds_result()
5212 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5213 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5214 
    result.write(oprot)
5215 
    oprot.writeMessageEnd()
5216 
    oprot.trans.flush()
7460 kshitij.so 5217 
 
7770 kshitij.so 5218 
 
5944 mandeep.dh 5219 
# HELPER FUNCTIONS AND STRUCTURES
5220 
 
5221 
class addItem_args:
5222 
  """
5223 
  Attributes:
5224 
   - item
5225 
  """
5226 
 
5227 
  thrift_spec = (
5228 
    None, # 0
5229 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5230 
  )
5231 
 
5232 
  def __init__(self, item=None,):
5233 
    self.item = item
5234 
 
5235 
  def read(self, iprot):
5236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5238 
      return
5239 
    iprot.readStructBegin()
5240 
    while True:
5241 
      (fname, ftype, fid) = iprot.readFieldBegin()
5242 
      if ftype == TType.STOP:
5243 
        break
5244 
      if fid == 1:
5245 
        if ftype == TType.STRUCT:
5246 
          self.item = Item()
5247 
          self.item.read(iprot)
5248 
        else:
5249 
          iprot.skip(ftype)
5250 
      else:
5251 
        iprot.skip(ftype)
5252 
      iprot.readFieldEnd()
5253 
    iprot.readStructEnd()
5254 
 
5255 
  def write(self, oprot):
5256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5258 
      return
5259 
    oprot.writeStructBegin('addItem_args')
5260 
    if self.item is not None:
5261 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5262 
      self.item.write(oprot)
5263 
      oprot.writeFieldEnd()
5264 
    oprot.writeFieldStop()
5265 
    oprot.writeStructEnd()
5266 
 
5267 
  def validate(self):
5268 
    return
5269 
 
5270 
 
5271 
  def __repr__(self):
5272 
    L = ['%s=%r' % (key, value)
5273 
      for key, value in self.__dict__.iteritems()]
5274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5275 
 
5276 
  def __eq__(self, other):
5277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5278 
 
5279 
  def __ne__(self, other):
5280 
    return not (self == other)
5281 
 
5282 
class addItem_result:
5283 
  """
5284 
  Attributes:
5285 
   - success
5286 
   - cex
5287 
  """
5288 
 
5289 
  thrift_spec = (
5290 
    (0, TType.I64, 'success', None, None, ), # 0
5291 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5292 
  )
5293 
 
5294 
  def __init__(self, success=None, cex=None,):
5295 
    self.success = success
5296 
    self.cex = cex
5297 
 
5298 
  def read(self, iprot):
5299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5301 
      return
5302 
    iprot.readStructBegin()
5303 
    while True:
5304 
      (fname, ftype, fid) = iprot.readFieldBegin()
5305 
      if ftype == TType.STOP:
5306 
        break
5307 
      if fid == 0:
5308 
        if ftype == TType.I64:
5309 
          self.success = iprot.readI64();
5310 
        else:
5311 
          iprot.skip(ftype)
5312 
      elif fid == 1:
5313 
        if ftype == TType.STRUCT:
5314 
          self.cex = CatalogServiceException()
5315 
          self.cex.read(iprot)
5316 
        else:
5317 
          iprot.skip(ftype)
5318 
      else:
5319 
        iprot.skip(ftype)
5320 
      iprot.readFieldEnd()
5321 
    iprot.readStructEnd()
5322 
 
5323 
  def write(self, oprot):
5324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5326 
      return
5327 
    oprot.writeStructBegin('addItem_result')
5328 
    if self.success is not None:
5329 
      oprot.writeFieldBegin('success', TType.I64, 0)
5330 
      oprot.writeI64(self.success)
5331 
      oprot.writeFieldEnd()
5332 
    if self.cex is not None:
5333 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5334 
      self.cex.write(oprot)
5335 
      oprot.writeFieldEnd()
5336 
    oprot.writeFieldStop()
5337 
    oprot.writeStructEnd()
5338 
 
5339 
  def validate(self):
5340 
    return
5341 
 
5342 
 
5343 
  def __repr__(self):
5344 
    L = ['%s=%r' % (key, value)
5345 
      for key, value in self.__dict__.iteritems()]
5346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5347 
 
5348 
  def __eq__(self, other):
5349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5350 
 
5351 
  def __ne__(self, other):
5352 
    return not (self == other)
5353 
 
5354 
class updateItem_args:
5355 
  """
5356 
  Attributes:
5357 
   - item
5358 
  """
5359 
 
5360 
  thrift_spec = (
5361 
    None, # 0
5362 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5363 
  )
5364 
 
5365 
  def __init__(self, item=None,):
5366 
    self.item = item
5367 
 
5368 
  def read(self, iprot):
5369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5371 
      return
5372 
    iprot.readStructBegin()
5373 
    while True:
5374 
      (fname, ftype, fid) = iprot.readFieldBegin()
5375 
      if ftype == TType.STOP:
5376 
        break
5377 
      if fid == 1:
5378 
        if ftype == TType.STRUCT:
5379 
          self.item = Item()
5380 
          self.item.read(iprot)
5381 
        else:
5382 
          iprot.skip(ftype)
5383 
      else:
5384 
        iprot.skip(ftype)
5385 
      iprot.readFieldEnd()
5386 
    iprot.readStructEnd()
5387 
 
5388 
  def write(self, oprot):
5389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5391 
      return
5392 
    oprot.writeStructBegin('updateItem_args')
5393 
    if self.item is not None:
5394 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5395 
      self.item.write(oprot)
5396 
      oprot.writeFieldEnd()
5397 
    oprot.writeFieldStop()
5398 
    oprot.writeStructEnd()
5399 
 
5400 
  def validate(self):
5401 
    return
5402 
 
5403 
 
5404 
  def __repr__(self):
5405 
    L = ['%s=%r' % (key, value)
5406 
      for key, value in self.__dict__.iteritems()]
5407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5408 
 
5409 
  def __eq__(self, other):
5410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5411 
 
5412 
  def __ne__(self, other):
5413 
    return not (self == other)
5414 
 
5415 
class updateItem_result:
5416 
  """
5417 
  Attributes:
5418 
   - success
5419 
   - cex
5420 
  """
5421 
 
5422 
  thrift_spec = (
5423 
    (0, TType.I64, 'success', None, None, ), # 0
5424 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5425 
  )
5426 
 
5427 
  def __init__(self, success=None, cex=None,):
5428 
    self.success = success
5429 
    self.cex = cex
5430 
 
5431 
  def read(self, iprot):
5432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5434 
      return
5435 
    iprot.readStructBegin()
5436 
    while True:
5437 
      (fname, ftype, fid) = iprot.readFieldBegin()
5438 
      if ftype == TType.STOP:
5439 
        break
5440 
      if fid == 0:
5441 
        if ftype == TType.I64:
5442 
          self.success = iprot.readI64();
5443 
        else:
5444 
          iprot.skip(ftype)
5445 
      elif fid == 1:
5446 
        if ftype == TType.STRUCT:
5447 
          self.cex = CatalogServiceException()
5448 
          self.cex.read(iprot)
5449 
        else:
5450 
          iprot.skip(ftype)
5451 
      else:
5452 
        iprot.skip(ftype)
5453 
      iprot.readFieldEnd()
5454 
    iprot.readStructEnd()
5455 
 
5456 
  def write(self, oprot):
5457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5459 
      return
5460 
    oprot.writeStructBegin('updateItem_result')
5461 
    if self.success is not None:
5462 
      oprot.writeFieldBegin('success', TType.I64, 0)
5463 
      oprot.writeI64(self.success)
5464 
      oprot.writeFieldEnd()
5465 
    if self.cex is not None:
5466 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5467 
      self.cex.write(oprot)
5468 
      oprot.writeFieldEnd()
5469 
    oprot.writeFieldStop()
5470 
    oprot.writeStructEnd()
5471 
 
5472 
  def validate(self):
5473 
    return
5474 
 
5475 
 
5476 
  def __repr__(self):
5477 
    L = ['%s=%r' % (key, value)
5478 
      for key, value in self.__dict__.iteritems()]
5479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5480 
 
5481 
  def __eq__(self, other):
5482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5483 
 
5484 
  def __ne__(self, other):
5485 
    return not (self == other)
5486 
 
5487 
class isActive_args:
5488 
  """
5489 
  Attributes:
5490 
   - itemId
5491 
  """
5492 
 
5493 
  thrift_spec = (
5494 
    None, # 0
5495 
    (1, TType.I64, 'itemId', None, None, ), # 1
5496 
  )
5497 
 
5498 
  def __init__(self, itemId=None,):
5499 
    self.itemId = itemId
5500 
 
5501 
  def read(self, iprot):
5502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5504 
      return
5505 
    iprot.readStructBegin()
5506 
    while True:
5507 
      (fname, ftype, fid) = iprot.readFieldBegin()
5508 
      if ftype == TType.STOP:
5509 
        break
5510 
      if fid == 1:
5511 
        if ftype == TType.I64:
5512 
          self.itemId = iprot.readI64();
5513 
        else:
5514 
          iprot.skip(ftype)
5515 
      else:
5516 
        iprot.skip(ftype)
5517 
      iprot.readFieldEnd()
5518 
    iprot.readStructEnd()
5519 
 
5520 
  def write(self, oprot):
5521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5523 
      return
5524 
    oprot.writeStructBegin('isActive_args')
5525 
    if self.itemId is not None:
5526 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5527 
      oprot.writeI64(self.itemId)
5528 
      oprot.writeFieldEnd()
5529 
    oprot.writeFieldStop()
5530 
    oprot.writeStructEnd()
5531 
 
5532 
  def validate(self):
5533 
    return
5534 
 
5535 
 
5536 
  def __repr__(self):
5537 
    L = ['%s=%r' % (key, value)
5538 
      for key, value in self.__dict__.iteritems()]
5539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5540 
 
5541 
  def __eq__(self, other):
5542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5543 
 
5544 
  def __ne__(self, other):
5545 
    return not (self == other)
5546 
 
5547 
class isActive_result:
5548 
  """
5549 
  Attributes:
5550 
   - success
5551 
   - isex
5552 
  """
5553 
 
5554 
  thrift_spec = (
5555 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5556 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5557 
  )
5558 
 
5559 
  def __init__(self, success=None, isex=None,):
5560 
    self.success = success
5561 
    self.isex = isex
5562 
 
5563 
  def read(self, iprot):
5564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5566 
      return
5567 
    iprot.readStructBegin()
5568 
    while True:
5569 
      (fname, ftype, fid) = iprot.readFieldBegin()
5570 
      if ftype == TType.STOP:
5571 
        break
5572 
      if fid == 0:
5573 
        if ftype == TType.STRUCT:
5574 
          self.success = ItemShippingInfo()
5575 
          self.success.read(iprot)
5576 
        else:
5577 
          iprot.skip(ftype)
5578 
      elif fid == 1:
5579 
        if ftype == TType.STRUCT:
5580 
          self.isex = CatalogServiceException()
5581 
          self.isex.read(iprot)
5582 
        else:
5583 
          iprot.skip(ftype)
5584 
      else:
5585 
        iprot.skip(ftype)
5586 
      iprot.readFieldEnd()
5587 
    iprot.readStructEnd()
5588 
 
5589 
  def write(self, oprot):
5590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5592 
      return
5593 
    oprot.writeStructBegin('isActive_result')
5594 
    if self.success is not None:
5595 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5596 
      self.success.write(oprot)
5597 
      oprot.writeFieldEnd()
5598 
    if self.isex is not None:
5599 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5600 
      self.isex.write(oprot)
5601 
      oprot.writeFieldEnd()
5602 
    oprot.writeFieldStop()
5603 
    oprot.writeStructEnd()
5604 
 
5605 
  def validate(self):
5606 
    return
5607 
 
5608 
 
5609 
  def __repr__(self):
5610 
    L = ['%s=%r' % (key, value)
5611 
      for key, value in self.__dict__.iteritems()]
5612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5613 
 
5614 
  def __eq__(self, other):
5615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5616 
 
5617 
  def __ne__(self, other):
5618 
    return not (self == other)
5619 
 
7438 amit.gupta 5620 
class getItemsStatus_args:
5621 
  """
5622 
  Attributes:
5623 
   - itemIds
5624 
  """
5625 
 
5626 
  thrift_spec = (
5627 
    None, # 0
5628 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5629 
  )
5630 
 
5631 
  def __init__(self, itemIds=None,):
5632 
    self.itemIds = itemIds
5633 
 
5634 
  def read(self, iprot):
5635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5637 
      return
5638 
    iprot.readStructBegin()
5639 
    while True:
5640 
      (fname, ftype, fid) = iprot.readFieldBegin()
5641 
      if ftype == TType.STOP:
5642 
        break
5643 
      if fid == 1:
5644 
        if ftype == TType.LIST:
5645 
          self.itemIds = []
5646 
          (_etype19, _size16) = iprot.readListBegin()
5647 
          for _i20 in xrange(_size16):
5648 
            _elem21 = iprot.readI64();
5649 
            self.itemIds.append(_elem21)
5650 
          iprot.readListEnd()
5651 
        else:
5652 
          iprot.skip(ftype)
5653 
      else:
5654 
        iprot.skip(ftype)
5655 
      iprot.readFieldEnd()
5656 
    iprot.readStructEnd()
5657 
 
5658 
  def write(self, oprot):
5659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5661 
      return
5662 
    oprot.writeStructBegin('getItemsStatus_args')
5663 
    if self.itemIds is not None:
5664 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5665 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5666 
      for iter22 in self.itemIds:
5667 
        oprot.writeI64(iter22)
5668 
      oprot.writeListEnd()
5669 
      oprot.writeFieldEnd()
5670 
    oprot.writeFieldStop()
5671 
    oprot.writeStructEnd()
5672 
 
5673 
  def validate(self):
5674 
    return
5675 
 
5676 
 
5677 
  def __repr__(self):
5678 
    L = ['%s=%r' % (key, value)
5679 
      for key, value in self.__dict__.iteritems()]
5680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5681 
 
5682 
  def __eq__(self, other):
5683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5684 
 
5685 
  def __ne__(self, other):
5686 
    return not (self == other)
5687 
 
5688 
class getItemsStatus_result:
5689 
  """
5690 
  Attributes:
5691 
   - success
5692 
   - isex
5693 
  """
5694 
 
5695 
  thrift_spec = (
5696 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5697 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5698 
  )
5699 
 
5700 
  def __init__(self, success=None, isex=None,):
5701 
    self.success = success
5702 
    self.isex = isex
5703 
 
5704 
  def read(self, iprot):
5705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5707 
      return
5708 
    iprot.readStructBegin()
5709 
    while True:
5710 
      (fname, ftype, fid) = iprot.readFieldBegin()
5711 
      if ftype == TType.STOP:
5712 
        break
5713 
      if fid == 0:
5714 
        if ftype == TType.MAP:
5715 
          self.success = {}
5716 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5717 
          for _i27 in xrange(_size23):
5718 
            _key28 = iprot.readI64();
5719 
            _val29 = iprot.readBool();
5720 
            self.success[_key28] = _val29
5721 
          iprot.readMapEnd()
5722 
        else:
5723 
          iprot.skip(ftype)
5724 
      elif fid == 1:
5725 
        if ftype == TType.STRUCT:
5726 
          self.isex = CatalogServiceException()
5727 
          self.isex.read(iprot)
5728 
        else:
5729 
          iprot.skip(ftype)
5730 
      else:
5731 
        iprot.skip(ftype)
5732 
      iprot.readFieldEnd()
5733 
    iprot.readStructEnd()
5734 
 
5735 
  def write(self, oprot):
5736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5738 
      return
5739 
    oprot.writeStructBegin('getItemsStatus_result')
5740 
    if self.success is not None:
5741 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5742 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5743 
      for kiter30,viter31 in self.success.items():
5744 
        oprot.writeI64(kiter30)
5745 
        oprot.writeBool(viter31)
5746 
      oprot.writeMapEnd()
5747 
      oprot.writeFieldEnd()
5748 
    if self.isex is not None:
5749 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5750 
      self.isex.write(oprot)
5751 
      oprot.writeFieldEnd()
5752 
    oprot.writeFieldStop()
5753 
    oprot.writeStructEnd()
5754 
 
5755 
  def validate(self):
5756 
    return
5757 
 
5758 
 
5759 
  def __repr__(self):
5760 
    L = ['%s=%r' % (key, value)
5761 
      for key, value in self.__dict__.iteritems()]
5762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5763 
 
5764 
  def __eq__(self, other):
5765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5766 
 
5767 
  def __ne__(self, other):
5768 
    return not (self == other)
5769 
 
5944 mandeep.dh 5770 
class getItemStatusDescription_args:
5771 
  """
5772 
  Attributes:
5773 
   - itemId
5774 
  """
5775 
 
5776 
  thrift_spec = (
5777 
    None, # 0
5778 
    (1, TType.I64, 'itemId', None, None, ), # 1
5779 
  )
5780 
 
5781 
  def __init__(self, itemId=None,):
5782 
    self.itemId = itemId
5783 
 
5784 
  def read(self, iprot):
5785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5787 
      return
5788 
    iprot.readStructBegin()
5789 
    while True:
5790 
      (fname, ftype, fid) = iprot.readFieldBegin()
5791 
      if ftype == TType.STOP:
5792 
        break
5793 
      if fid == 1:
5794 
        if ftype == TType.I64:
5795 
          self.itemId = iprot.readI64();
5796 
        else:
5797 
          iprot.skip(ftype)
5798 
      else:
5799 
        iprot.skip(ftype)
5800 
      iprot.readFieldEnd()
5801 
    iprot.readStructEnd()
5802 
 
5803 
  def write(self, oprot):
5804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5806 
      return
5807 
    oprot.writeStructBegin('getItemStatusDescription_args')
5808 
    if self.itemId is not None:
5809 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5810 
      oprot.writeI64(self.itemId)
5811 
      oprot.writeFieldEnd()
5812 
    oprot.writeFieldStop()
5813 
    oprot.writeStructEnd()
5814 
 
5815 
  def validate(self):
5816 
    return
5817 
 
5818 
 
5819 
  def __repr__(self):
5820 
    L = ['%s=%r' % (key, value)
5821 
      for key, value in self.__dict__.iteritems()]
5822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5823 
 
5824 
  def __eq__(self, other):
5825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5826 
 
5827 
  def __ne__(self, other):
5828 
    return not (self == other)
5829 
 
5830 
class getItemStatusDescription_result:
5831 
  """
5832 
  Attributes:
5833 
   - success
5834 
   - isex
5835 
  """
5836 
 
5837 
  thrift_spec = (
5838 
    (0, TType.STRING, 'success', None, None, ), # 0
5839 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5840 
  )
5841 
 
5842 
  def __init__(self, success=None, isex=None,):
5843 
    self.success = success
5844 
    self.isex = isex
5845 
 
5846 
  def read(self, iprot):
5847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5849 
      return
5850 
    iprot.readStructBegin()
5851 
    while True:
5852 
      (fname, ftype, fid) = iprot.readFieldBegin()
5853 
      if ftype == TType.STOP:
5854 
        break
5855 
      if fid == 0:
5856 
        if ftype == TType.STRING:
5857 
          self.success = iprot.readString();
5858 
        else:
5859 
          iprot.skip(ftype)
5860 
      elif fid == 1:
5861 
        if ftype == TType.STRUCT:
5862 
          self.isex = CatalogServiceException()
5863 
          self.isex.read(iprot)
5864 
        else:
5865 
          iprot.skip(ftype)
5866 
      else:
5867 
        iprot.skip(ftype)
5868 
      iprot.readFieldEnd()
5869 
    iprot.readStructEnd()
5870 
 
5871 
  def write(self, oprot):
5872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5874 
      return
5875 
    oprot.writeStructBegin('getItemStatusDescription_result')
5876 
    if self.success is not None:
5877 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5878 
      oprot.writeString(self.success)
5879 
      oprot.writeFieldEnd()
5880 
    if self.isex is not None:
5881 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5882 
      self.isex.write(oprot)
5883 
      oprot.writeFieldEnd()
5884 
    oprot.writeFieldStop()
5885 
    oprot.writeStructEnd()
5886 
 
5887 
  def validate(self):
5888 
    return
5889 
 
5890 
 
5891 
  def __repr__(self):
5892 
    L = ['%s=%r' % (key, value)
5893 
      for key, value in self.__dict__.iteritems()]
5894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5895 
 
5896 
  def __eq__(self, other):
5897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5898 
 
5899 
  def __ne__(self, other):
5900 
    return not (self == other)
5901 
 
5902 
class startItemOn_args:
5903 
  """
5904 
  Attributes:
5905 
   - item_id
5906 
   - timestamp
5907 
  """
5908 
 
5909 
  thrift_spec = (
5910 
    None, # 0
5911 
    (1, TType.I64, 'item_id', None, None, ), # 1
5912 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5913 
  )
5914 
 
5915 
  def __init__(self, item_id=None, timestamp=None,):
5916 
    self.item_id = item_id
5917 
    self.timestamp = timestamp
5918 
 
5919 
  def read(self, iprot):
5920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5922 
      return
5923 
    iprot.readStructBegin()
5924 
    while True:
5925 
      (fname, ftype, fid) = iprot.readFieldBegin()
5926 
      if ftype == TType.STOP:
5927 
        break
5928 
      if fid == 1:
5929 
        if ftype == TType.I64:
5930 
          self.item_id = iprot.readI64();
5931 
        else:
5932 
          iprot.skip(ftype)
5933 
      elif fid == 2:
5934 
        if ftype == TType.I64:
5935 
          self.timestamp = iprot.readI64();
5936 
        else:
5937 
          iprot.skip(ftype)
5938 
      else:
5939 
        iprot.skip(ftype)
5940 
      iprot.readFieldEnd()
5941 
    iprot.readStructEnd()
5942 
 
5943 
  def write(self, oprot):
5944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5946 
      return
5947 
    oprot.writeStructBegin('startItemOn_args')
5948 
    if self.item_id is not None:
5949 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5950 
      oprot.writeI64(self.item_id)
5951 
      oprot.writeFieldEnd()
5952 
    if self.timestamp is not None:
5953 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5954 
      oprot.writeI64(self.timestamp)
5955 
      oprot.writeFieldEnd()
5956 
    oprot.writeFieldStop()
5957 
    oprot.writeStructEnd()
5958 
 
5959 
  def validate(self):
5960 
    return
5961 
 
5962 
 
5963 
  def __repr__(self):
5964 
    L = ['%s=%r' % (key, value)
5965 
      for key, value in self.__dict__.iteritems()]
5966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5967 
 
5968 
  def __eq__(self, other):
5969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5970 
 
5971 
  def __ne__(self, other):
5972 
    return not (self == other)
5973 
 
5974 
class startItemOn_result:
5975 
  """
5976 
  Attributes:
5977 
   - cex
5978 
  """
5979 
 
5980 
  thrift_spec = (
5981 
    None, # 0
5982 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5983 
  )
5984 
 
5985 
  def __init__(self, cex=None,):
5986 
    self.cex = cex
5987 
 
5988 
  def read(self, iprot):
5989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5991 
      return
5992 
    iprot.readStructBegin()
5993 
    while True:
5994 
      (fname, ftype, fid) = iprot.readFieldBegin()
5995 
      if ftype == TType.STOP:
5996 
        break
5997 
      if fid == 1:
5998 
        if ftype == TType.STRUCT:
5999 
          self.cex = CatalogServiceException()
6000 
          self.cex.read(iprot)
6001 
        else:
6002 
          iprot.skip(ftype)
6003 
      else:
6004 
        iprot.skip(ftype)
6005 
      iprot.readFieldEnd()
6006 
    iprot.readStructEnd()
6007 
 
6008 
  def write(self, oprot):
6009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6011 
      return
6012 
    oprot.writeStructBegin('startItemOn_result')
6013 
    if self.cex is not None:
6014 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6015 
      self.cex.write(oprot)
6016 
      oprot.writeFieldEnd()
6017 
    oprot.writeFieldStop()
6018 
    oprot.writeStructEnd()
6019 
 
6020 
  def validate(self):
6021 
    return
6022 
 
6023 
 
6024 
  def __repr__(self):
6025 
    L = ['%s=%r' % (key, value)
6026 
      for key, value in self.__dict__.iteritems()]
6027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6028 
 
6029 
  def __eq__(self, other):
6030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6031 
 
6032 
  def __ne__(self, other):
6033 
    return not (self == other)
6034 
 
6035 
class retireItemOn_args:
6036 
  """
6037 
  Attributes:
6038 
   - item_id
6039 
   - timestamp
6040 
  """
6041 
 
6042 
  thrift_spec = (
6043 
    None, # 0
6044 
    (1, TType.I64, 'item_id', None, None, ), # 1
6045 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6046 
  )
6047 
 
6048 
  def __init__(self, item_id=None, timestamp=None,):
6049 
    self.item_id = item_id
6050 
    self.timestamp = timestamp
6051 
 
6052 
  def read(self, iprot):
6053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6055 
      return
6056 
    iprot.readStructBegin()
6057 
    while True:
6058 
      (fname, ftype, fid) = iprot.readFieldBegin()
6059 
      if ftype == TType.STOP:
6060 
        break
6061 
      if fid == 1:
6062 
        if ftype == TType.I64:
6063 
          self.item_id = iprot.readI64();
6064 
        else:
6065 
          iprot.skip(ftype)
6066 
      elif fid == 2:
6067 
        if ftype == TType.I64:
6068 
          self.timestamp = iprot.readI64();
6069 
        else:
6070 
          iprot.skip(ftype)
6071 
      else:
6072 
        iprot.skip(ftype)
6073 
      iprot.readFieldEnd()
6074 
    iprot.readStructEnd()
6075 
 
6076 
  def write(self, oprot):
6077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6079 
      return
6080 
    oprot.writeStructBegin('retireItemOn_args')
6081 
    if self.item_id is not None:
6082 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6083 
      oprot.writeI64(self.item_id)
6084 
      oprot.writeFieldEnd()
6085 
    if self.timestamp is not None:
6086 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6087 
      oprot.writeI64(self.timestamp)
6088 
      oprot.writeFieldEnd()
6089 
    oprot.writeFieldStop()
6090 
    oprot.writeStructEnd()
6091 
 
6092 
  def validate(self):
6093 
    return
6094 
 
6095 
 
6096 
  def __repr__(self):
6097 
    L = ['%s=%r' % (key, value)
6098 
      for key, value in self.__dict__.iteritems()]
6099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6100 
 
6101 
  def __eq__(self, other):
6102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6103 
 
6104 
  def __ne__(self, other):
6105 
    return not (self == other)
6106 
 
6107 
class retireItemOn_result:
6108 
  """
6109 
  Attributes:
6110 
   - cex
6111 
  """
6112 
 
6113 
  thrift_spec = (
6114 
    None, # 0
6115 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6116 
  )
6117 
 
6118 
  def __init__(self, cex=None,):
6119 
    self.cex = cex
6120 
 
6121 
  def read(self, iprot):
6122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6124 
      return
6125 
    iprot.readStructBegin()
6126 
    while True:
6127 
      (fname, ftype, fid) = iprot.readFieldBegin()
6128 
      if ftype == TType.STOP:
6129 
        break
6130 
      if fid == 1:
6131 
        if ftype == TType.STRUCT:
6132 
          self.cex = CatalogServiceException()
6133 
          self.cex.read(iprot)
6134 
        else:
6135 
          iprot.skip(ftype)
6136 
      else:
6137 
        iprot.skip(ftype)
6138 
      iprot.readFieldEnd()
6139 
    iprot.readStructEnd()
6140 
 
6141 
  def write(self, oprot):
6142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6144 
      return
6145 
    oprot.writeStructBegin('retireItemOn_result')
6146 
    if self.cex is not None:
6147 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6148 
      self.cex.write(oprot)
6149 
      oprot.writeFieldEnd()
6150 
    oprot.writeFieldStop()
6151 
    oprot.writeStructEnd()
6152 
 
6153 
  def validate(self):
6154 
    return
6155 
 
6156 
 
6157 
  def __repr__(self):
6158 
    L = ['%s=%r' % (key, value)
6159 
      for key, value in self.__dict__.iteritems()]
6160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6161 
 
6162 
  def __eq__(self, other):
6163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6164 
 
6165 
  def __ne__(self, other):
6166 
    return not (self == other)
6167 
 
6168 
class changeItemStatus_args:
6169 
  """
6170 
  Attributes:
6171 
   - item_id
6172 
   - timestamp
6173 
   - newstatus
6174 
  """
6175 
 
6176 
  thrift_spec = (
6177 
    None, # 0
6178 
    (1, TType.I64, 'item_id', None, None, ), # 1
6179 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6180 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6181 
  )
6182 
 
6183 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6184 
    self.item_id = item_id
6185 
    self.timestamp = timestamp
6186 
    self.newstatus = newstatus
6187 
 
6188 
  def read(self, iprot):
6189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6191 
      return
6192 
    iprot.readStructBegin()
6193 
    while True:
6194 
      (fname, ftype, fid) = iprot.readFieldBegin()
6195 
      if ftype == TType.STOP:
6196 
        break
6197 
      if fid == 1:
6198 
        if ftype == TType.I64:
6199 
          self.item_id = iprot.readI64();
6200 
        else:
6201 
          iprot.skip(ftype)
6202 
      elif fid == 2:
6203 
        if ftype == TType.I64:
6204 
          self.timestamp = iprot.readI64();
6205 
        else:
6206 
          iprot.skip(ftype)
6207 
      elif fid == 3:
6208 
        if ftype == TType.I32:
6209 
          self.newstatus = iprot.readI32();
6210 
        else:
6211 
          iprot.skip(ftype)
6212 
      else:
6213 
        iprot.skip(ftype)
6214 
      iprot.readFieldEnd()
6215 
    iprot.readStructEnd()
6216 
 
6217 
  def write(self, oprot):
6218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6220 
      return
6221 
    oprot.writeStructBegin('changeItemStatus_args')
6222 
    if self.item_id is not None:
6223 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6224 
      oprot.writeI64(self.item_id)
6225 
      oprot.writeFieldEnd()
6226 
    if self.timestamp is not None:
6227 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6228 
      oprot.writeI64(self.timestamp)
6229 
      oprot.writeFieldEnd()
6230 
    if self.newstatus is not None:
6231 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6232 
      oprot.writeI32(self.newstatus)
6233 
      oprot.writeFieldEnd()
6234 
    oprot.writeFieldStop()
6235 
    oprot.writeStructEnd()
6236 
 
6237 
  def validate(self):
6238 
    return
6239 
 
6240 
 
6241 
  def __repr__(self):
6242 
    L = ['%s=%r' % (key, value)
6243 
      for key, value in self.__dict__.iteritems()]
6244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6245 
 
6246 
  def __eq__(self, other):
6247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6248 
 
6249 
  def __ne__(self, other):
6250 
    return not (self == other)
6251 
 
6252 
class changeItemStatus_result:
6253 
  """
6254 
  Attributes:
6255 
   - cex
6256 
  """
6257 
 
6258 
  thrift_spec = (
6259 
    None, # 0
6260 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6261 
  )
6262 
 
6263 
  def __init__(self, cex=None,):
6264 
    self.cex = cex
6265 
 
6266 
  def read(self, iprot):
6267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6269 
      return
6270 
    iprot.readStructBegin()
6271 
    while True:
6272 
      (fname, ftype, fid) = iprot.readFieldBegin()
6273 
      if ftype == TType.STOP:
6274 
        break
6275 
      if fid == 1:
6276 
        if ftype == TType.STRUCT:
6277 
          self.cex = CatalogServiceException()
6278 
          self.cex.read(iprot)
6279 
        else:
6280 
          iprot.skip(ftype)
6281 
      else:
6282 
        iprot.skip(ftype)
6283 
      iprot.readFieldEnd()
6284 
    iprot.readStructEnd()
6285 
 
6286 
  def write(self, oprot):
6287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6289 
      return
6290 
    oprot.writeStructBegin('changeItemStatus_result')
6291 
    if self.cex is not None:
6292 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6293 
      self.cex.write(oprot)
6294 
      oprot.writeFieldEnd()
6295 
    oprot.writeFieldStop()
6296 
    oprot.writeStructEnd()
6297 
 
6298 
  def validate(self):
6299 
    return
6300 
 
6301 
 
6302 
  def __repr__(self):
6303 
    L = ['%s=%r' % (key, value)
6304 
      for key, value in self.__dict__.iteritems()]
6305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6306 
 
6307 
  def __eq__(self, other):
6308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6309 
 
6310 
  def __ne__(self, other):
6311 
    return not (self == other)
6312 
 
6313 
class getItem_args:
6314 
  """
6315 
  Attributes:
6316 
   - item_id
6317 
  """
6318 
 
6319 
  thrift_spec = (
6320 
    None, # 0
6321 
    (1, TType.I64, 'item_id', None, None, ), # 1
6322 
  )
6323 
 
6324 
  def __init__(self, item_id=None,):
6325 
    self.item_id = item_id
6326 
 
6327 
  def read(self, iprot):
6328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6330 
      return
6331 
    iprot.readStructBegin()
6332 
    while True:
6333 
      (fname, ftype, fid) = iprot.readFieldBegin()
6334 
      if ftype == TType.STOP:
6335 
        break
6336 
      if fid == 1:
6337 
        if ftype == TType.I64:
6338 
          self.item_id = iprot.readI64();
6339 
        else:
6340 
          iprot.skip(ftype)
6341 
      else:
6342 
        iprot.skip(ftype)
6343 
      iprot.readFieldEnd()
6344 
    iprot.readStructEnd()
6345 
 
6346 
  def write(self, oprot):
6347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6349 
      return
6350 
    oprot.writeStructBegin('getItem_args')
6351 
    if self.item_id is not None:
6352 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6353 
      oprot.writeI64(self.item_id)
6354 
      oprot.writeFieldEnd()
6355 
    oprot.writeFieldStop()
6356 
    oprot.writeStructEnd()
6357 
 
6358 
  def validate(self):
6359 
    return
6360 
 
6361 
 
6362 
  def __repr__(self):
6363 
    L = ['%s=%r' % (key, value)
6364 
      for key, value in self.__dict__.iteritems()]
6365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6366 
 
6367 
  def __eq__(self, other):
6368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6369 
 
6370 
  def __ne__(self, other):
6371 
    return not (self == other)
6372 
 
6373 
class getItem_result:
6374 
  """
6375 
  Attributes:
6376 
   - success
6377 
   - cex
6378 
  """
6379 
 
6380 
  thrift_spec = (
6381 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6382 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6383 
  )
6384 
 
6385 
  def __init__(self, success=None, cex=None,):
6386 
    self.success = success
6387 
    self.cex = cex
6388 
 
6389 
  def read(self, iprot):
6390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6392 
      return
6393 
    iprot.readStructBegin()
6394 
    while True:
6395 
      (fname, ftype, fid) = iprot.readFieldBegin()
6396 
      if ftype == TType.STOP:
6397 
        break
6398 
      if fid == 0:
6399 
        if ftype == TType.STRUCT:
6400 
          self.success = Item()
6401 
          self.success.read(iprot)
6402 
        else:
6403 
          iprot.skip(ftype)
6404 
      elif fid == 1:
6405 
        if ftype == TType.STRUCT:
6406 
          self.cex = CatalogServiceException()
6407 
          self.cex.read(iprot)
6408 
        else:
6409 
          iprot.skip(ftype)
6410 
      else:
6411 
        iprot.skip(ftype)
6412 
      iprot.readFieldEnd()
6413 
    iprot.readStructEnd()
6414 
 
6415 
  def write(self, oprot):
6416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6418 
      return
6419 
    oprot.writeStructBegin('getItem_result')
6420 
    if self.success is not None:
6421 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6422 
      self.success.write(oprot)
6423 
      oprot.writeFieldEnd()
6424 
    if self.cex is not None:
6425 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6426 
      self.cex.write(oprot)
6427 
      oprot.writeFieldEnd()
6428 
    oprot.writeFieldStop()
6429 
    oprot.writeStructEnd()
6430 
 
6431 
  def validate(self):
6432 
    return
6433 
 
6434 
 
6435 
  def __repr__(self):
6436 
    L = ['%s=%r' % (key, value)
6437 
      for key, value in self.__dict__.iteritems()]
6438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6439 
 
6440 
  def __eq__(self, other):
6441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6442 
 
6443 
  def __ne__(self, other):
6444 
    return not (self == other)
6445 
 
6446 
class getItemsByCatalogId_args:
6447 
  """
6448 
  Attributes:
6449 
   - catalog_item_id
6450 
  """
6451 
 
6452 
  thrift_spec = (
6453 
    None, # 0
6454 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6455 
  )
6456 
 
6457 
  def __init__(self, catalog_item_id=None,):
6458 
    self.catalog_item_id = catalog_item_id
6459 
 
6460 
  def read(self, iprot):
6461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6463 
      return
6464 
    iprot.readStructBegin()
6465 
    while True:
6466 
      (fname, ftype, fid) = iprot.readFieldBegin()
6467 
      if ftype == TType.STOP:
6468 
        break
6469 
      if fid == 1:
6470 
        if ftype == TType.I64:
6471 
          self.catalog_item_id = iprot.readI64();
6472 
        else:
6473 
          iprot.skip(ftype)
6474 
      else:
6475 
        iprot.skip(ftype)
6476 
      iprot.readFieldEnd()
6477 
    iprot.readStructEnd()
6478 
 
6479 
  def write(self, oprot):
6480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6482 
      return
6483 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6484 
    if self.catalog_item_id is not None:
6485 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6486 
      oprot.writeI64(self.catalog_item_id)
6487 
      oprot.writeFieldEnd()
6488 
    oprot.writeFieldStop()
6489 
    oprot.writeStructEnd()
6490 
 
6491 
  def validate(self):
6492 
    return
6493 
 
6494 
 
6495 
  def __repr__(self):
6496 
    L = ['%s=%r' % (key, value)
6497 
      for key, value in self.__dict__.iteritems()]
6498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6499 
 
6500 
  def __eq__(self, other):
6501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6502 
 
6503 
  def __ne__(self, other):
6504 
    return not (self == other)
6505 
 
6506 
class getItemsByCatalogId_result:
6507 
  """
6508 
  Attributes:
6509 
   - success
6510 
   - cex
6511 
  """
6512 
 
6513 
  thrift_spec = (
6514 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6515 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6516 
  )
6517 
 
6518 
  def __init__(self, success=None, cex=None,):
6519 
    self.success = success
6520 
    self.cex = cex
6521 
 
6522 
  def read(self, iprot):
6523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6525 
      return
6526 
    iprot.readStructBegin()
6527 
    while True:
6528 
      (fname, ftype, fid) = iprot.readFieldBegin()
6529 
      if ftype == TType.STOP:
6530 
        break
6531 
      if fid == 0:
6532 
        if ftype == TType.LIST:
6533 
          self.success = []
7438 amit.gupta 6534 
          (_etype35, _size32) = iprot.readListBegin()
6535 
          for _i36 in xrange(_size32):
6536 
            _elem37 = Item()
6537 
            _elem37.read(iprot)
6538 
            self.success.append(_elem37)
5944 mandeep.dh 6539 
          iprot.readListEnd()
6540 
        else:
6541 
          iprot.skip(ftype)
6542 
      elif fid == 1:
6543 
        if ftype == TType.STRUCT:
6544 
          self.cex = CatalogServiceException()
6545 
          self.cex.read(iprot)
6546 
        else:
6547 
          iprot.skip(ftype)
6548 
      else:
6549 
        iprot.skip(ftype)
6550 
      iprot.readFieldEnd()
6551 
    iprot.readStructEnd()
6552 
 
6553 
  def write(self, oprot):
6554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6556 
      return
6557 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6558 
    if self.success is not None:
6559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6561 
      for iter38 in self.success:
6562 
        iter38.write(oprot)
5944 mandeep.dh 6563 
      oprot.writeListEnd()
6564 
      oprot.writeFieldEnd()
6565 
    if self.cex is not None:
6566 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6567 
      self.cex.write(oprot)
6568 
      oprot.writeFieldEnd()
6569 
    oprot.writeFieldStop()
6570 
    oprot.writeStructEnd()
6571 
 
6572 
  def validate(self):
6573 
    return
6574 
 
6575 
 
6576 
  def __repr__(self):
6577 
    L = ['%s=%r' % (key, value)
6578 
      for key, value in self.__dict__.iteritems()]
6579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6580 
 
6581 
  def __eq__(self, other):
6582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6583 
 
6584 
  def __ne__(self, other):
6585 
    return not (self == other)
6586 
 
6587 
class getValidItemsByCatalogId_args:
6588 
  """
6589 
  Attributes:
6590 
   - catalog_item_id
6591 
  """
6592 
 
6593 
  thrift_spec = (
6594 
    None, # 0
6595 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6596 
  )
6597 
 
6598 
  def __init__(self, catalog_item_id=None,):
6599 
    self.catalog_item_id = catalog_item_id
6600 
 
6601 
  def read(self, iprot):
6602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6604 
      return
6605 
    iprot.readStructBegin()
6606 
    while True:
6607 
      (fname, ftype, fid) = iprot.readFieldBegin()
6608 
      if ftype == TType.STOP:
6609 
        break
6610 
      if fid == 1:
6611 
        if ftype == TType.I64:
6612 
          self.catalog_item_id = iprot.readI64();
6613 
        else:
6614 
          iprot.skip(ftype)
6615 
      else:
6616 
        iprot.skip(ftype)
6617 
      iprot.readFieldEnd()
6618 
    iprot.readStructEnd()
6619 
 
6620 
  def write(self, oprot):
6621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6623 
      return
6624 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6625 
    if self.catalog_item_id is not None:
6626 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6627 
      oprot.writeI64(self.catalog_item_id)
6628 
      oprot.writeFieldEnd()
6629 
    oprot.writeFieldStop()
6630 
    oprot.writeStructEnd()
6631 
 
6632 
  def validate(self):
6633 
    return
6634 
 
6635 
 
6636 
  def __repr__(self):
6637 
    L = ['%s=%r' % (key, value)
6638 
      for key, value in self.__dict__.iteritems()]
6639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6640 
 
6641 
  def __eq__(self, other):
6642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6643 
 
6644 
  def __ne__(self, other):
6645 
    return not (self == other)
6646 
 
6647 
class getValidItemsByCatalogId_result:
6648 
  """
6649 
  Attributes:
6650 
   - success
6651 
   - cex
6652 
  """
6653 
 
6654 
  thrift_spec = (
6655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6656 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6657 
  )
6658 
 
6659 
  def __init__(self, success=None, cex=None,):
6660 
    self.success = success
6661 
    self.cex = cex
6662 
 
6663 
  def read(self, iprot):
6664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6666 
      return
6667 
    iprot.readStructBegin()
6668 
    while True:
6669 
      (fname, ftype, fid) = iprot.readFieldBegin()
6670 
      if ftype == TType.STOP:
6671 
        break
6672 
      if fid == 0:
6673 
        if ftype == TType.LIST:
6674 
          self.success = []
7438 amit.gupta 6675 
          (_etype42, _size39) = iprot.readListBegin()
6676 
          for _i43 in xrange(_size39):
6677 
            _elem44 = Item()
6678 
            _elem44.read(iprot)
6679 
            self.success.append(_elem44)
5944 mandeep.dh 6680 
          iprot.readListEnd()
6681 
        else:
6682 
          iprot.skip(ftype)
6683 
      elif fid == 1:
6684 
        if ftype == TType.STRUCT:
6685 
          self.cex = CatalogServiceException()
6686 
          self.cex.read(iprot)
6687 
        else:
6688 
          iprot.skip(ftype)
6689 
      else:
6690 
        iprot.skip(ftype)
6691 
      iprot.readFieldEnd()
6692 
    iprot.readStructEnd()
6693 
 
6694 
  def write(self, oprot):
6695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6697 
      return
6698 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6699 
    if self.success is not None:
6700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6702 
      for iter45 in self.success:
6703 
        iter45.write(oprot)
5944 mandeep.dh 6704 
      oprot.writeListEnd()
6705 
      oprot.writeFieldEnd()
6706 
    if self.cex is not None:
6707 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6708 
      self.cex.write(oprot)
6709 
      oprot.writeFieldEnd()
6710 
    oprot.writeFieldStop()
6711 
    oprot.writeStructEnd()
6712 
 
6713 
  def validate(self):
6714 
    return
6715 
 
6716 
 
6717 
  def __repr__(self):
6718 
    L = ['%s=%r' % (key, value)
6719 
      for key, value in self.__dict__.iteritems()]
6720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6721 
 
6722 
  def __eq__(self, other):
6723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6724 
 
6725 
  def __ne__(self, other):
6726 
    return not (self == other)
6727 
 
6728 
class getAllItems_args:
6729 
  """
6730 
  Attributes:
6731 
   - isActive
6732 
  """
6733 
 
6734 
  thrift_spec = (
6735 
    None, # 0
6736 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6737 
  )
6738 
 
6739 
  def __init__(self, isActive=None,):
6740 
    self.isActive = isActive
6741 
 
6742 
  def read(self, iprot):
6743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6745 
      return
6746 
    iprot.readStructBegin()
6747 
    while True:
6748 
      (fname, ftype, fid) = iprot.readFieldBegin()
6749 
      if ftype == TType.STOP:
6750 
        break
6751 
      if fid == 1:
6752 
        if ftype == TType.BOOL:
6753 
          self.isActive = iprot.readBool();
6754 
        else:
6755 
          iprot.skip(ftype)
6756 
      else:
6757 
        iprot.skip(ftype)
6758 
      iprot.readFieldEnd()
6759 
    iprot.readStructEnd()
6760 
 
6761 
  def write(self, oprot):
6762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6764 
      return
6765 
    oprot.writeStructBegin('getAllItems_args')
6766 
    if self.isActive is not None:
6767 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6768 
      oprot.writeBool(self.isActive)
6769 
      oprot.writeFieldEnd()
6770 
    oprot.writeFieldStop()
6771 
    oprot.writeStructEnd()
6772 
 
6773 
  def validate(self):
6774 
    return
6775 
 
6776 
 
6777 
  def __repr__(self):
6778 
    L = ['%s=%r' % (key, value)
6779 
      for key, value in self.__dict__.iteritems()]
6780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6781 
 
6782 
  def __eq__(self, other):
6783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6784 
 
6785 
  def __ne__(self, other):
6786 
    return not (self == other)
6787 
 
6788 
class getAllItems_result:
6789 
  """
6790 
  Attributes:
6791 
   - success
6792 
   - cex
6793 
  """
6794 
 
6795 
  thrift_spec = (
6796 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6797 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6798 
  )
6799 
 
6800 
  def __init__(self, success=None, cex=None,):
6801 
    self.success = success
6802 
    self.cex = cex
6803 
 
6804 
  def read(self, iprot):
6805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6807 
      return
6808 
    iprot.readStructBegin()
6809 
    while True:
6810 
      (fname, ftype, fid) = iprot.readFieldBegin()
6811 
      if ftype == TType.STOP:
6812 
        break
6813 
      if fid == 0:
6814 
        if ftype == TType.LIST:
6815 
          self.success = []
7438 amit.gupta 6816 
          (_etype49, _size46) = iprot.readListBegin()
6817 
          for _i50 in xrange(_size46):
6818 
            _elem51 = Item()
6819 
            _elem51.read(iprot)
6820 
            self.success.append(_elem51)
5944 mandeep.dh 6821 
          iprot.readListEnd()
6822 
        else:
6823 
          iprot.skip(ftype)
6824 
      elif fid == 1:
6825 
        if ftype == TType.STRUCT:
6826 
          self.cex = CatalogServiceException()
6827 
          self.cex.read(iprot)
6828 
        else:
6829 
          iprot.skip(ftype)
6830 
      else:
6831 
        iprot.skip(ftype)
6832 
      iprot.readFieldEnd()
6833 
    iprot.readStructEnd()
6834 
 
6835 
  def write(self, oprot):
6836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6838 
      return
6839 
    oprot.writeStructBegin('getAllItems_result')
6840 
    if self.success is not None:
6841 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6842 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6843 
      for iter52 in self.success:
6844 
        iter52.write(oprot)
5944 mandeep.dh 6845 
      oprot.writeListEnd()
6846 
      oprot.writeFieldEnd()
6847 
    if self.cex is not None:
6848 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6849 
      self.cex.write(oprot)
6850 
      oprot.writeFieldEnd()
6851 
    oprot.writeFieldStop()
6852 
    oprot.writeStructEnd()
6853 
 
6854 
  def validate(self):
6855 
    return
6856 
 
6857 
 
6858 
  def __repr__(self):
6859 
    L = ['%s=%r' % (key, value)
6860 
      for key, value in self.__dict__.iteritems()]
6861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6862 
 
6863 
  def __eq__(self, other):
6864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6865 
 
6866 
  def __ne__(self, other):
6867 
    return not (self == other)
6868 
 
6869 
class getAllItemsByStatus_args:
6870 
  """
6871 
  Attributes:
6872 
   - itemStatus
6873 
  """
6874 
 
6875 
  thrift_spec = (
6876 
    None, # 0
6877 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6878 
  )
6879 
 
6880 
  def __init__(self, itemStatus=None,):
6881 
    self.itemStatus = itemStatus
6882 
 
6883 
  def read(self, iprot):
6884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6886 
      return
6887 
    iprot.readStructBegin()
6888 
    while True:
6889 
      (fname, ftype, fid) = iprot.readFieldBegin()
6890 
      if ftype == TType.STOP:
6891 
        break
6892 
      if fid == 1:
6893 
        if ftype == TType.I32:
6894 
          self.itemStatus = iprot.readI32();
6895 
        else:
6896 
          iprot.skip(ftype)
6897 
      else:
6898 
        iprot.skip(ftype)
6899 
      iprot.readFieldEnd()
6900 
    iprot.readStructEnd()
6901 
 
6902 
  def write(self, oprot):
6903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6905 
      return
6906 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6907 
    if self.itemStatus is not None:
6908 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6909 
      oprot.writeI32(self.itemStatus)
6910 
      oprot.writeFieldEnd()
6911 
    oprot.writeFieldStop()
6912 
    oprot.writeStructEnd()
6913 
 
6914 
  def validate(self):
6915 
    return
6916 
 
6917 
 
6918 
  def __repr__(self):
6919 
    L = ['%s=%r' % (key, value)
6920 
      for key, value in self.__dict__.iteritems()]
6921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6922 
 
6923 
  def __eq__(self, other):
6924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6925 
 
6926 
  def __ne__(self, other):
6927 
    return not (self == other)
6928 
 
6929 
class getAllItemsByStatus_result:
6930 
  """
6931 
  Attributes:
6932 
   - success
6933 
   - cex
6934 
  """
6935 
 
6936 
  thrift_spec = (
6937 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6938 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6939 
  )
6940 
 
6941 
  def __init__(self, success=None, cex=None,):
6942 
    self.success = success
6943 
    self.cex = cex
6944 
 
6945 
  def read(self, iprot):
6946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6948 
      return
6949 
    iprot.readStructBegin()
6950 
    while True:
6951 
      (fname, ftype, fid) = iprot.readFieldBegin()
6952 
      if ftype == TType.STOP:
6953 
        break
6954 
      if fid == 0:
6955 
        if ftype == TType.LIST:
6956 
          self.success = []
7438 amit.gupta 6957 
          (_etype56, _size53) = iprot.readListBegin()
6958 
          for _i57 in xrange(_size53):
6959 
            _elem58 = Item()
6960 
            _elem58.read(iprot)
6961 
            self.success.append(_elem58)
5944 mandeep.dh 6962 
          iprot.readListEnd()
6963 
        else:
6964 
          iprot.skip(ftype)
6965 
      elif fid == 1:
6966 
        if ftype == TType.STRUCT:
6967 
          self.cex = CatalogServiceException()
6968 
          self.cex.read(iprot)
6969 
        else:
6970 
          iprot.skip(ftype)
6971 
      else:
6972 
        iprot.skip(ftype)
6973 
      iprot.readFieldEnd()
6974 
    iprot.readStructEnd()
6975 
 
6976 
  def write(self, oprot):
6977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6979 
      return
6980 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6981 
    if self.success is not None:
6982 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6983 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6984 
      for iter59 in self.success:
6985 
        iter59.write(oprot)
5944 mandeep.dh 6986 
      oprot.writeListEnd()
6987 
      oprot.writeFieldEnd()
6988 
    if self.cex is not None:
6989 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6990 
      self.cex.write(oprot)
6991 
      oprot.writeFieldEnd()
6992 
    oprot.writeFieldStop()
6993 
    oprot.writeStructEnd()
6994 
 
6995 
  def validate(self):
6996 
    return
6997 
 
6998 
 
6999 
  def __repr__(self):
7000 
    L = ['%s=%r' % (key, value)
7001 
      for key, value in self.__dict__.iteritems()]
7002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7003 
 
7004 
  def __eq__(self, other):
7005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7006 
 
7007 
  def __ne__(self, other):
7008 
    return not (self == other)
7009 
 
7010 
class markItemAsContentComplete_args:
7011 
  """
7012 
  Attributes:
7013 
   - entityId
7014 
   - category
7015 
   - brand
7016 
   - modelName
7017 
   - modelNumber
7018 
  """
7019 
 
7020 
  thrift_spec = (
7021 
    None, # 0
7022 
    (1, TType.I64, 'entityId', None, None, ), # 1
7023 
    (2, TType.I64, 'category', None, None, ), # 2
7024 
    (3, TType.STRING, 'brand', None, None, ), # 3
7025 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7026 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7027 
  )
7028 
 
7029 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7030 
    self.entityId = entityId
7031 
    self.category = category
7032 
    self.brand = brand
7033 
    self.modelName = modelName
7034 
    self.modelNumber = modelNumber
7035 
 
7036 
  def read(self, iprot):
7037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7039 
      return
7040 
    iprot.readStructBegin()
7041 
    while True:
7042 
      (fname, ftype, fid) = iprot.readFieldBegin()
7043 
      if ftype == TType.STOP:
7044 
        break
7045 
      if fid == 1:
7046 
        if ftype == TType.I64:
7047 
          self.entityId = iprot.readI64();
7048 
        else:
7049 
          iprot.skip(ftype)
7050 
      elif fid == 2:
7051 
        if ftype == TType.I64:
7052 
          self.category = iprot.readI64();
7053 
        else:
7054 
          iprot.skip(ftype)
7055 
      elif fid == 3:
7056 
        if ftype == TType.STRING:
7057 
          self.brand = iprot.readString();
7058 
        else:
7059 
          iprot.skip(ftype)
7060 
      elif fid == 4:
7061 
        if ftype == TType.STRING:
7062 
          self.modelName = iprot.readString();
7063 
        else:
7064 
          iprot.skip(ftype)
7065 
      elif fid == 5:
7066 
        if ftype == TType.STRING:
7067 
          self.modelNumber = iprot.readString();
7068 
        else:
7069 
          iprot.skip(ftype)
7070 
      else:
7071 
        iprot.skip(ftype)
7072 
      iprot.readFieldEnd()
7073 
    iprot.readStructEnd()
7074 
 
7075 
  def write(self, oprot):
7076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7078 
      return
7079 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7080 
    if self.entityId is not None:
7081 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7082 
      oprot.writeI64(self.entityId)
7083 
      oprot.writeFieldEnd()
7084 
    if self.category is not None:
7085 
      oprot.writeFieldBegin('category', TType.I64, 2)
7086 
      oprot.writeI64(self.category)
7087 
      oprot.writeFieldEnd()
7088 
    if self.brand is not None:
7089 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7090 
      oprot.writeString(self.brand)
7091 
      oprot.writeFieldEnd()
7092 
    if self.modelName is not None:
7093 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7094 
      oprot.writeString(self.modelName)
7095 
      oprot.writeFieldEnd()
7096 
    if self.modelNumber is not None:
7097 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7098 
      oprot.writeString(self.modelNumber)
7099 
      oprot.writeFieldEnd()
7100 
    oprot.writeFieldStop()
7101 
    oprot.writeStructEnd()
7102 
 
7103 
  def validate(self):
7104 
    return
7105 
 
7106 
 
7107 
  def __repr__(self):
7108 
    L = ['%s=%r' % (key, value)
7109 
      for key, value in self.__dict__.iteritems()]
7110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7111 
 
7112 
  def __eq__(self, other):
7113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7114 
 
7115 
  def __ne__(self, other):
7116 
    return not (self == other)
7117 
 
7118 
class markItemAsContentComplete_result:
7119 
  """
7120 
  Attributes:
7121 
   - success
7122 
   - cex
7123 
  """
7124 
 
7125 
  thrift_spec = (
7126 
    (0, TType.BOOL, 'success', None, None, ), # 0
7127 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7128 
  )
7129 
 
7130 
  def __init__(self, success=None, cex=None,):
7131 
    self.success = success
7132 
    self.cex = cex
7133 
 
7134 
  def read(self, iprot):
7135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7137 
      return
7138 
    iprot.readStructBegin()
7139 
    while True:
7140 
      (fname, ftype, fid) = iprot.readFieldBegin()
7141 
      if ftype == TType.STOP:
7142 
        break
7143 
      if fid == 0:
7144 
        if ftype == TType.BOOL:
7145 
          self.success = iprot.readBool();
7146 
        else:
7147 
          iprot.skip(ftype)
7148 
      elif fid == 1:
7149 
        if ftype == TType.STRUCT:
7150 
          self.cex = CatalogServiceException()
7151 
          self.cex.read(iprot)
7152 
        else:
7153 
          iprot.skip(ftype)
7154 
      else:
7155 
        iprot.skip(ftype)
7156 
      iprot.readFieldEnd()
7157 
    iprot.readStructEnd()
7158 
 
7159 
  def write(self, oprot):
7160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7162 
      return
7163 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7164 
    if self.success is not None:
7165 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7166 
      oprot.writeBool(self.success)
7167 
      oprot.writeFieldEnd()
7168 
    if self.cex is not None:
7169 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7170 
      self.cex.write(oprot)
7171 
      oprot.writeFieldEnd()
7172 
    oprot.writeFieldStop()
7173 
    oprot.writeStructEnd()
7174 
 
7175 
  def validate(self):
7176 
    return
7177 
 
7178 
 
7179 
  def __repr__(self):
7180 
    L = ['%s=%r' % (key, value)
7181 
      for key, value in self.__dict__.iteritems()]
7182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7183 
 
7184 
  def __eq__(self, other):
7185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7186 
 
7187 
  def __ne__(self, other):
7188 
    return not (self == other)
7189 
 
7190 
class getAllItemsInRange_args:
7191 
  """
7192 
  Attributes:
7193 
   - offset
7194 
   - limit
7195 
  """
7196 
 
7197 
  thrift_spec = (
7198 
    None, # 0
7199 
    (1, TType.I64, 'offset', None, None, ), # 1
7200 
    (2, TType.I64, 'limit', None, None, ), # 2
7201 
  )
7202 
 
7203 
  def __init__(self, offset=None, limit=None,):
7204 
    self.offset = offset
7205 
    self.limit = limit
7206 
 
7207 
  def read(self, iprot):
7208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7210 
      return
7211 
    iprot.readStructBegin()
7212 
    while True:
7213 
      (fname, ftype, fid) = iprot.readFieldBegin()
7214 
      if ftype == TType.STOP:
7215 
        break
7216 
      if fid == 1:
7217 
        if ftype == TType.I64:
7218 
          self.offset = iprot.readI64();
7219 
        else:
7220 
          iprot.skip(ftype)
7221 
      elif fid == 2:
7222 
        if ftype == TType.I64:
7223 
          self.limit = iprot.readI64();
7224 
        else:
7225 
          iprot.skip(ftype)
7226 
      else:
7227 
        iprot.skip(ftype)
7228 
      iprot.readFieldEnd()
7229 
    iprot.readStructEnd()
7230 
 
7231 
  def write(self, oprot):
7232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7234 
      return
7235 
    oprot.writeStructBegin('getAllItemsInRange_args')
7236 
    if self.offset is not None:
7237 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7238 
      oprot.writeI64(self.offset)
7239 
      oprot.writeFieldEnd()
7240 
    if self.limit is not None:
7241 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7242 
      oprot.writeI64(self.limit)
7243 
      oprot.writeFieldEnd()
7244 
    oprot.writeFieldStop()
7245 
    oprot.writeStructEnd()
7246 
 
7247 
  def validate(self):
7248 
    return
7249 
 
7250 
 
7251 
  def __repr__(self):
7252 
    L = ['%s=%r' % (key, value)
7253 
      for key, value in self.__dict__.iteritems()]
7254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7255 
 
7256 
  def __eq__(self, other):
7257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7258 
 
7259 
  def __ne__(self, other):
7260 
    return not (self == other)
7261 
 
7262 
class getAllItemsInRange_result:
7263 
  """
7264 
  Attributes:
7265 
   - success
7266 
   - cex
7267 
  """
7268 
 
7269 
  thrift_spec = (
7270 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7271 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7272 
  )
7273 
 
7274 
  def __init__(self, success=None, cex=None,):
7275 
    self.success = success
7276 
    self.cex = cex
7277 
 
7278 
  def read(self, iprot):
7279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7281 
      return
7282 
    iprot.readStructBegin()
7283 
    while True:
7284 
      (fname, ftype, fid) = iprot.readFieldBegin()
7285 
      if ftype == TType.STOP:
7286 
        break
7287 
      if fid == 0:
7288 
        if ftype == TType.LIST:
7289 
          self.success = []
7438 amit.gupta 7290 
          (_etype63, _size60) = iprot.readListBegin()
7291 
          for _i64 in xrange(_size60):
7292 
            _elem65 = Item()
7293 
            _elem65.read(iprot)
7294 
            self.success.append(_elem65)
5944 mandeep.dh 7295 
          iprot.readListEnd()
7296 
        else:
7297 
          iprot.skip(ftype)
7298 
      elif fid == 1:
7299 
        if ftype == TType.STRUCT:
7300 
          self.cex = CatalogServiceException()
7301 
          self.cex.read(iprot)
7302 
        else:
7303 
          iprot.skip(ftype)
7304 
      else:
7305 
        iprot.skip(ftype)
7306 
      iprot.readFieldEnd()
7307 
    iprot.readStructEnd()
7308 
 
7309 
  def write(self, oprot):
7310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7312 
      return
7313 
    oprot.writeStructBegin('getAllItemsInRange_result')
7314 
    if self.success is not None:
7315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7317 
      for iter66 in self.success:
7318 
        iter66.write(oprot)
5944 mandeep.dh 7319 
      oprot.writeListEnd()
7320 
      oprot.writeFieldEnd()
7321 
    if self.cex is not None:
7322 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7323 
      self.cex.write(oprot)
7324 
      oprot.writeFieldEnd()
7325 
    oprot.writeFieldStop()
7326 
    oprot.writeStructEnd()
7327 
 
7328 
  def validate(self):
7329 
    return
7330 
 
7331 
 
7332 
  def __repr__(self):
7333 
    L = ['%s=%r' % (key, value)
7334 
      for key, value in self.__dict__.iteritems()]
7335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7336 
 
7337 
  def __eq__(self, other):
7338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7339 
 
7340 
  def __ne__(self, other):
7341 
    return not (self == other)
7342 
 
7343 
class getAllItemsByStatusInRange_args:
7344 
  """
7345 
  Attributes:
7346 
   - itemStatus
7347 
   - offset
7348 
   - limit
7349 
  """
7350 
 
7351 
  thrift_spec = (
7352 
    None, # 0
7353 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7354 
    (2, TType.I64, 'offset', None, None, ), # 2
7355 
    (3, TType.I64, 'limit', None, None, ), # 3
7356 
  )
7357 
 
7358 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7359 
    self.itemStatus = itemStatus
7360 
    self.offset = offset
7361 
    self.limit = limit
7362 
 
7363 
  def read(self, iprot):
7364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7366 
      return
7367 
    iprot.readStructBegin()
7368 
    while True:
7369 
      (fname, ftype, fid) = iprot.readFieldBegin()
7370 
      if ftype == TType.STOP:
7371 
        break
7372 
      if fid == 1:
7373 
        if ftype == TType.I32:
7374 
          self.itemStatus = iprot.readI32();
7375 
        else:
7376 
          iprot.skip(ftype)
7377 
      elif fid == 2:
7378 
        if ftype == TType.I64:
7379 
          self.offset = iprot.readI64();
7380 
        else:
7381 
          iprot.skip(ftype)
7382 
      elif fid == 3:
7383 
        if ftype == TType.I64:
7384 
          self.limit = iprot.readI64();
7385 
        else:
7386 
          iprot.skip(ftype)
7387 
      else:
7388 
        iprot.skip(ftype)
7389 
      iprot.readFieldEnd()
7390 
    iprot.readStructEnd()
7391 
 
7392 
  def write(self, oprot):
7393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7395 
      return
7396 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7397 
    if self.itemStatus is not None:
7398 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7399 
      oprot.writeI32(self.itemStatus)
7400 
      oprot.writeFieldEnd()
7401 
    if self.offset is not None:
7402 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7403 
      oprot.writeI64(self.offset)
7404 
      oprot.writeFieldEnd()
7405 
    if self.limit is not None:
7406 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7407 
      oprot.writeI64(self.limit)
7408 
      oprot.writeFieldEnd()
7409 
    oprot.writeFieldStop()
7410 
    oprot.writeStructEnd()
7411 
 
7412 
  def validate(self):
7413 
    return
7414 
 
7415 
 
7416 
  def __repr__(self):
7417 
    L = ['%s=%r' % (key, value)
7418 
      for key, value in self.__dict__.iteritems()]
7419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7420 
 
7421 
  def __eq__(self, other):
7422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7423 
 
7424 
  def __ne__(self, other):
7425 
    return not (self == other)
7426 
 
7427 
class getAllItemsByStatusInRange_result:
7428 
  """
7429 
  Attributes:
7430 
   - success
7431 
   - cex
7432 
  """
7433 
 
7434 
  thrift_spec = (
7435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7436 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7437 
  )
7438 
 
7439 
  def __init__(self, success=None, cex=None,):
7440 
    self.success = success
7441 
    self.cex = cex
7442 
 
7443 
  def read(self, iprot):
7444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7446 
      return
7447 
    iprot.readStructBegin()
7448 
    while True:
7449 
      (fname, ftype, fid) = iprot.readFieldBegin()
7450 
      if ftype == TType.STOP:
7451 
        break
7452 
      if fid == 0:
7453 
        if ftype == TType.LIST:
7454 
          self.success = []
7438 amit.gupta 7455 
          (_etype70, _size67) = iprot.readListBegin()
7456 
          for _i71 in xrange(_size67):
7457 
            _elem72 = Item()
7458 
            _elem72.read(iprot)
7459 
            self.success.append(_elem72)
5944 mandeep.dh 7460 
          iprot.readListEnd()
7461 
        else:
7462 
          iprot.skip(ftype)
7463 
      elif fid == 1:
7464 
        if ftype == TType.STRUCT:
7465 
          self.cex = CatalogServiceException()
7466 
          self.cex.read(iprot)
7467 
        else:
7468 
          iprot.skip(ftype)
7469 
      else:
7470 
        iprot.skip(ftype)
7471 
      iprot.readFieldEnd()
7472 
    iprot.readStructEnd()
7473 
 
7474 
  def write(self, oprot):
7475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7477 
      return
7478 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7479 
    if self.success is not None:
7480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7482 
      for iter73 in self.success:
7483 
        iter73.write(oprot)
5944 mandeep.dh 7484 
      oprot.writeListEnd()
7485 
      oprot.writeFieldEnd()
7486 
    if self.cex is not None:
7487 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7488 
      self.cex.write(oprot)
7489 
      oprot.writeFieldEnd()
7490 
    oprot.writeFieldStop()
7491 
    oprot.writeStructEnd()
7492 
 
7493 
  def validate(self):
7494 
    return
7495 
 
7496 
 
7497 
  def __repr__(self):
7498 
    L = ['%s=%r' % (key, value)
7499 
      for key, value in self.__dict__.iteritems()]
7500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7501 
 
7502 
  def __eq__(self, other):
7503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7504 
 
7505 
  def __ne__(self, other):
7506 
    return not (self == other)
7507 
 
7508 
class getItemCountByStatus_args:
7509 
  """
7510 
  Attributes:
7511 
   - useStatus
7512 
   - itemStatus
7513 
  """
7514 
 
7515 
  thrift_spec = (
7516 
    None, # 0
7517 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7518 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7519 
  )
7520 
 
7521 
  def __init__(self, useStatus=None, itemStatus=None,):
7522 
    self.useStatus = useStatus
7523 
    self.itemStatus = itemStatus
7524 
 
7525 
  def read(self, iprot):
7526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7528 
      return
7529 
    iprot.readStructBegin()
7530 
    while True:
7531 
      (fname, ftype, fid) = iprot.readFieldBegin()
7532 
      if ftype == TType.STOP:
7533 
        break
7534 
      if fid == 1:
7535 
        if ftype == TType.BOOL:
7536 
          self.useStatus = iprot.readBool();
7537 
        else:
7538 
          iprot.skip(ftype)
7539 
      elif fid == 2:
7540 
        if ftype == TType.I32:
7541 
          self.itemStatus = iprot.readI32();
7542 
        else:
7543 
          iprot.skip(ftype)
7544 
      else:
7545 
        iprot.skip(ftype)
7546 
      iprot.readFieldEnd()
7547 
    iprot.readStructEnd()
7548 
 
7549 
  def write(self, oprot):
7550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7552 
      return
7553 
    oprot.writeStructBegin('getItemCountByStatus_args')
7554 
    if self.useStatus is not None:
7555 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7556 
      oprot.writeBool(self.useStatus)
7557 
      oprot.writeFieldEnd()
7558 
    if self.itemStatus is not None:
7559 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7560 
      oprot.writeI32(self.itemStatus)
7561 
      oprot.writeFieldEnd()
7562 
    oprot.writeFieldStop()
7563 
    oprot.writeStructEnd()
7564 
 
7565 
  def validate(self):
7566 
    return
7567 
 
7568 
 
7569 
  def __repr__(self):
7570 
    L = ['%s=%r' % (key, value)
7571 
      for key, value in self.__dict__.iteritems()]
7572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7573 
 
7574 
  def __eq__(self, other):
7575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7576 
 
7577 
  def __ne__(self, other):
7578 
    return not (self == other)
7579 
 
7580 
class getItemCountByStatus_result:
7581 
  """
7582 
  Attributes:
7583 
   - success
7584 
  """
7585 
 
7586 
  thrift_spec = (
7587 
    (0, TType.I32, 'success', None, None, ), # 0
7588 
  )
7589 
 
7590 
  def __init__(self, success=None,):
7591 
    self.success = success
7592 
 
7593 
  def read(self, iprot):
7594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7596 
      return
7597 
    iprot.readStructBegin()
7598 
    while True:
7599 
      (fname, ftype, fid) = iprot.readFieldBegin()
7600 
      if ftype == TType.STOP:
7601 
        break
7602 
      if fid == 0:
7603 
        if ftype == TType.I32:
7604 
          self.success = iprot.readI32();
7605 
        else:
7606 
          iprot.skip(ftype)
7607 
      else:
7608 
        iprot.skip(ftype)
7609 
      iprot.readFieldEnd()
7610 
    iprot.readStructEnd()
7611 
 
7612 
  def write(self, oprot):
7613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7615 
      return
7616 
    oprot.writeStructBegin('getItemCountByStatus_result')
7617 
    if self.success is not None:
7618 
      oprot.writeFieldBegin('success', TType.I32, 0)
7619 
      oprot.writeI32(self.success)
7620 
      oprot.writeFieldEnd()
7621 
    oprot.writeFieldStop()
7622 
    oprot.writeStructEnd()
7623 
 
7624 
  def validate(self):
7625 
    return
7626 
 
7627 
 
7628 
  def __repr__(self):
7629 
    L = ['%s=%r' % (key, value)
7630 
      for key, value in self.__dict__.iteritems()]
7631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7632 
 
7633 
  def __eq__(self, other):
7634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7635 
 
7636 
  def __ne__(self, other):
7637 
    return not (self == other)
7638 
 
7639 
class getBestSellers_args:
7640 
 
7641 
  thrift_spec = (
7642 
  )
7643 
 
7644 
  def read(self, iprot):
7645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7647 
      return
7648 
    iprot.readStructBegin()
7649 
    while True:
7650 
      (fname, ftype, fid) = iprot.readFieldBegin()
7651 
      if ftype == TType.STOP:
7652 
        break
7653 
      else:
7654 
        iprot.skip(ftype)
7655 
      iprot.readFieldEnd()
7656 
    iprot.readStructEnd()
7657 
 
7658 
  def write(self, oprot):
7659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7661 
      return
7662 
    oprot.writeStructBegin('getBestSellers_args')
7663 
    oprot.writeFieldStop()
7664 
    oprot.writeStructEnd()
7665 
 
7666 
  def validate(self):
7667 
    return
7668 
 
7669 
 
7670 
  def __repr__(self):
7671 
    L = ['%s=%r' % (key, value)
7672 
      for key, value in self.__dict__.iteritems()]
7673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7674 
 
7675 
  def __eq__(self, other):
7676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7677 
 
7678 
  def __ne__(self, other):
7679 
    return not (self == other)
7680 
 
7681 
class getBestSellers_result:
7682 
  """
7683 
  Attributes:
7684 
   - success
7685 
   - isex
7686 
  """
7687 
 
7688 
  thrift_spec = (
7689 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7690 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7691 
  )
7692 
 
7693 
  def __init__(self, success=None, isex=None,):
7694 
    self.success = success
7695 
    self.isex = isex
7696 
 
7697 
  def read(self, iprot):
7698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7700 
      return
7701 
    iprot.readStructBegin()
7702 
    while True:
7703 
      (fname, ftype, fid) = iprot.readFieldBegin()
7704 
      if ftype == TType.STOP:
7705 
        break
7706 
      if fid == 0:
7707 
        if ftype == TType.LIST:
7708 
          self.success = []
7438 amit.gupta 7709 
          (_etype77, _size74) = iprot.readListBegin()
7710 
          for _i78 in xrange(_size74):
7711 
            _elem79 = Item()
7712 
            _elem79.read(iprot)
7713 
            self.success.append(_elem79)
5944 mandeep.dh 7714 
          iprot.readListEnd()
7715 
        else:
7716 
          iprot.skip(ftype)
7717 
      elif fid == 1:
7718 
        if ftype == TType.STRUCT:
7719 
          self.isex = CatalogServiceException()
7720 
          self.isex.read(iprot)
7721 
        else:
7722 
          iprot.skip(ftype)
7723 
      else:
7724 
        iprot.skip(ftype)
7725 
      iprot.readFieldEnd()
7726 
    iprot.readStructEnd()
7727 
 
7728 
  def write(self, oprot):
7729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7731 
      return
7732 
    oprot.writeStructBegin('getBestSellers_result')
7733 
    if self.success is not None:
7734 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7735 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7736 
      for iter80 in self.success:
7737 
        iter80.write(oprot)
5944 mandeep.dh 7738 
      oprot.writeListEnd()
7739 
      oprot.writeFieldEnd()
7740 
    if self.isex is not None:
7741 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7742 
      self.isex.write(oprot)
7743 
      oprot.writeFieldEnd()
7744 
    oprot.writeFieldStop()
7745 
    oprot.writeStructEnd()
7746 
 
7747 
  def validate(self):
7748 
    return
7749 
 
7750 
 
7751 
  def __repr__(self):
7752 
    L = ['%s=%r' % (key, value)
7753 
      for key, value in self.__dict__.iteritems()]
7754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7755 
 
7756 
  def __eq__(self, other):
7757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7758 
 
7759 
  def __ne__(self, other):
7760 
    return not (self == other)
7761 
 
7762 
class getBestSellersCatalogIds_args:
7763 
  """
7764 
  Attributes:
7765 
   - beginIndex
7766 
   - totalItems
7767 
   - brand
7768 
   - category
7769 
  """
7770 
 
7771 
  thrift_spec = (
7772 
    None, # 0
7773 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7774 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7775 
    (3, TType.STRING, 'brand', None, None, ), # 3
7776 
    (4, TType.I64, 'category', None, None, ), # 4
7777 
  )
7778 
 
7779 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7780 
    self.beginIndex = beginIndex
7781 
    self.totalItems = totalItems
7782 
    self.brand = brand
7783 
    self.category = category
7784 
 
7785 
  def read(self, iprot):
7786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7788 
      return
7789 
    iprot.readStructBegin()
7790 
    while True:
7791 
      (fname, ftype, fid) = iprot.readFieldBegin()
7792 
      if ftype == TType.STOP:
7793 
        break
7794 
      if fid == 1:
7795 
        if ftype == TType.I64:
7796 
          self.beginIndex = iprot.readI64();
7797 
        else:
7798 
          iprot.skip(ftype)
7799 
      elif fid == 2:
7800 
        if ftype == TType.I64:
7801 
          self.totalItems = iprot.readI64();
7802 
        else:
7803 
          iprot.skip(ftype)
7804 
      elif fid == 3:
7805 
        if ftype == TType.STRING:
7806 
          self.brand = iprot.readString();
7807 
        else:
7808 
          iprot.skip(ftype)
7809 
      elif fid == 4:
7810 
        if ftype == TType.I64:
7811 
          self.category = iprot.readI64();
7812 
        else:
7813 
          iprot.skip(ftype)
7814 
      else:
7815 
        iprot.skip(ftype)
7816 
      iprot.readFieldEnd()
7817 
    iprot.readStructEnd()
7818 
 
7819 
  def write(self, oprot):
7820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7822 
      return
7823 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7824 
    if self.beginIndex is not None:
7825 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7826 
      oprot.writeI64(self.beginIndex)
7827 
      oprot.writeFieldEnd()
7828 
    if self.totalItems is not None:
7829 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7830 
      oprot.writeI64(self.totalItems)
7831 
      oprot.writeFieldEnd()
7832 
    if self.brand is not None:
7833 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7834 
      oprot.writeString(self.brand)
7835 
      oprot.writeFieldEnd()
7836 
    if self.category is not None:
7837 
      oprot.writeFieldBegin('category', TType.I64, 4)
7838 
      oprot.writeI64(self.category)
7839 
      oprot.writeFieldEnd()
7840 
    oprot.writeFieldStop()
7841 
    oprot.writeStructEnd()
7842 
 
7843 
  def validate(self):
7844 
    return
7845 
 
7846 
 
7847 
  def __repr__(self):
7848 
    L = ['%s=%r' % (key, value)
7849 
      for key, value in self.__dict__.iteritems()]
7850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7851 
 
7852 
  def __eq__(self, other):
7853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7854 
 
7855 
  def __ne__(self, other):
7856 
    return not (self == other)
7857 
 
7858 
class getBestSellersCatalogIds_result:
7859 
  """
7860 
  Attributes:
7861 
   - success
7862 
   - cex
7863 
  """
7864 
 
7865 
  thrift_spec = (
7866 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7867 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7868 
  )
7869 
 
7870 
  def __init__(self, success=None, cex=None,):
7871 
    self.success = success
7872 
    self.cex = cex
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 == 0:
7884 
        if ftype == TType.LIST:
7885 
          self.success = []
7438 amit.gupta 7886 
          (_etype84, _size81) = iprot.readListBegin()
7887 
          for _i85 in xrange(_size81):
7888 
            _elem86 = iprot.readI64();
7889 
            self.success.append(_elem86)
5944 mandeep.dh 7890 
          iprot.readListEnd()
7891 
        else:
7892 
          iprot.skip(ftype)
7893 
      elif fid == 1:
7894 
        if ftype == TType.STRUCT:
7895 
          self.cex = CatalogServiceException()
7896 
          self.cex.read(iprot)
7897 
        else:
7898 
          iprot.skip(ftype)
7899 
      else:
7900 
        iprot.skip(ftype)
7901 
      iprot.readFieldEnd()
7902 
    iprot.readStructEnd()
7903 
 
7904 
  def write(self, oprot):
7905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7907 
      return
7908 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7909 
    if self.success is not None:
7910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7911 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 7912 
      for iter87 in self.success:
7913 
        oprot.writeI64(iter87)
5944 mandeep.dh 7914 
      oprot.writeListEnd()
7915 
      oprot.writeFieldEnd()
7916 
    if self.cex is not None:
7917 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7918 
      self.cex.write(oprot)
7919 
      oprot.writeFieldEnd()
7920 
    oprot.writeFieldStop()
7921 
    oprot.writeStructEnd()
7922 
 
7923 
  def validate(self):
7924 
    return
7925 
 
7926 
 
7927 
  def __repr__(self):
7928 
    L = ['%s=%r' % (key, value)
7929 
      for key, value in self.__dict__.iteritems()]
7930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7931 
 
7932 
  def __eq__(self, other):
7933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7934 
 
7935 
  def __ne__(self, other):
7936 
    return not (self == other)
7937 
 
7938 
class getBestSellersCount_args:
7939 
 
7940 
  thrift_spec = (
7941 
  )
7942 
 
7943 
  def read(self, iprot):
7944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7946 
      return
7947 
    iprot.readStructBegin()
7948 
    while True:
7949 
      (fname, ftype, fid) = iprot.readFieldBegin()
7950 
      if ftype == TType.STOP:
7951 
        break
7952 
      else:
7953 
        iprot.skip(ftype)
7954 
      iprot.readFieldEnd()
7955 
    iprot.readStructEnd()
7956 
 
7957 
  def write(self, oprot):
7958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7960 
      return
7961 
    oprot.writeStructBegin('getBestSellersCount_args')
7962 
    oprot.writeFieldStop()
7963 
    oprot.writeStructEnd()
7964 
 
7965 
  def validate(self):
7966 
    return
7967 
 
7968 
 
7969 
  def __repr__(self):
7970 
    L = ['%s=%r' % (key, value)
7971 
      for key, value in self.__dict__.iteritems()]
7972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7973 
 
7974 
  def __eq__(self, other):
7975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7976 
 
7977 
  def __ne__(self, other):
7978 
    return not (self == other)
7979 
 
7980 
class getBestSellersCount_result:
7981 
  """
7982 
  Attributes:
7983 
   - success
7984 
   - cex
7985 
  """
7986 
 
7987 
  thrift_spec = (
7988 
    (0, TType.I64, 'success', None, None, ), # 0
7989 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7990 
  )
7991 
 
7992 
  def __init__(self, success=None, cex=None,):
7993 
    self.success = success
7994 
    self.cex = cex
7995 
 
7996 
  def read(self, iprot):
7997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7999 
      return
8000 
    iprot.readStructBegin()
8001 
    while True:
8002 
      (fname, ftype, fid) = iprot.readFieldBegin()
8003 
      if ftype == TType.STOP:
8004 
        break
8005 
      if fid == 0:
8006 
        if ftype == TType.I64:
8007 
          self.success = iprot.readI64();
8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      elif fid == 1:
8011 
        if ftype == TType.STRUCT:
8012 
          self.cex = CatalogServiceException()
8013 
          self.cex.read(iprot)
8014 
        else:
8015 
          iprot.skip(ftype)
8016 
      else:
8017 
        iprot.skip(ftype)
8018 
      iprot.readFieldEnd()
8019 
    iprot.readStructEnd()
8020 
 
8021 
  def write(self, oprot):
8022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8024 
      return
8025 
    oprot.writeStructBegin('getBestSellersCount_result')
8026 
    if self.success is not None:
8027 
      oprot.writeFieldBegin('success', TType.I64, 0)
8028 
      oprot.writeI64(self.success)
8029 
      oprot.writeFieldEnd()
8030 
    if self.cex is not None:
8031 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8032 
      self.cex.write(oprot)
8033 
      oprot.writeFieldEnd()
8034 
    oprot.writeFieldStop()
8035 
    oprot.writeStructEnd()
8036 
 
8037 
  def validate(self):
8038 
    return
8039 
 
8040 
 
8041 
  def __repr__(self):
8042 
    L = ['%s=%r' % (key, value)
8043 
      for key, value in self.__dict__.iteritems()]
8044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8045 
 
8046 
  def __eq__(self, other):
8047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8048 
 
8049 
  def __ne__(self, other):
8050 
    return not (self == other)
8051 
 
8052 
class getBestDeals_args:
8053 
 
8054 
  thrift_spec = (
8055 
  )
8056 
 
8057 
  def read(self, iprot):
8058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8060 
      return
8061 
    iprot.readStructBegin()
8062 
    while True:
8063 
      (fname, ftype, fid) = iprot.readFieldBegin()
8064 
      if ftype == TType.STOP:
8065 
        break
8066 
      else:
8067 
        iprot.skip(ftype)
8068 
      iprot.readFieldEnd()
8069 
    iprot.readStructEnd()
8070 
 
8071 
  def write(self, oprot):
8072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8074 
      return
8075 
    oprot.writeStructBegin('getBestDeals_args')
8076 
    oprot.writeFieldStop()
8077 
    oprot.writeStructEnd()
8078 
 
8079 
  def validate(self):
8080 
    return
8081 
 
8082 
 
8083 
  def __repr__(self):
8084 
    L = ['%s=%r' % (key, value)
8085 
      for key, value in self.__dict__.iteritems()]
8086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8087 
 
8088 
  def __eq__(self, other):
8089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8090 
 
8091 
  def __ne__(self, other):
8092 
    return not (self == other)
8093 
 
8094 
class getBestDeals_result:
8095 
  """
8096 
  Attributes:
8097 
   - success
8098 
   - isex
8099 
  """
8100 
 
8101 
  thrift_spec = (
8102 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8103 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8104 
  )
8105 
 
8106 
  def __init__(self, success=None, isex=None,):
8107 
    self.success = success
8108 
    self.isex = isex
8109 
 
8110 
  def read(self, iprot):
8111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8113 
      return
8114 
    iprot.readStructBegin()
8115 
    while True:
8116 
      (fname, ftype, fid) = iprot.readFieldBegin()
8117 
      if ftype == TType.STOP:
8118 
        break
8119 
      if fid == 0:
8120 
        if ftype == TType.LIST:
8121 
          self.success = []
7438 amit.gupta 8122 
          (_etype91, _size88) = iprot.readListBegin()
8123 
          for _i92 in xrange(_size88):
8124 
            _elem93 = Item()
8125 
            _elem93.read(iprot)
8126 
            self.success.append(_elem93)
5944 mandeep.dh 8127 
          iprot.readListEnd()
8128 
        else:
8129 
          iprot.skip(ftype)
8130 
      elif fid == 1:
8131 
        if ftype == TType.STRUCT:
8132 
          self.isex = CatalogServiceException()
8133 
          self.isex.read(iprot)
8134 
        else:
8135 
          iprot.skip(ftype)
8136 
      else:
8137 
        iprot.skip(ftype)
8138 
      iprot.readFieldEnd()
8139 
    iprot.readStructEnd()
8140 
 
8141 
  def write(self, oprot):
8142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8144 
      return
8145 
    oprot.writeStructBegin('getBestDeals_result')
8146 
    if self.success is not None:
8147 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8148 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8149 
      for iter94 in self.success:
8150 
        iter94.write(oprot)
5944 mandeep.dh 8151 
      oprot.writeListEnd()
8152 
      oprot.writeFieldEnd()
8153 
    if self.isex is not None:
8154 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8155 
      self.isex.write(oprot)
8156 
      oprot.writeFieldEnd()
8157 
    oprot.writeFieldStop()
8158 
    oprot.writeStructEnd()
8159 
 
8160 
  def validate(self):
8161 
    return
8162 
 
8163 
 
8164 
  def __repr__(self):
8165 
    L = ['%s=%r' % (key, value)
8166 
      for key, value in self.__dict__.iteritems()]
8167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8168 
 
8169 
  def __eq__(self, other):
8170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8171 
 
8172 
  def __ne__(self, other):
8173 
    return not (self == other)
8174 
 
8175 
class getBestDealsCatalogIds_args:
8176 
  """
8177 
  Attributes:
8178 
   - beginIndex
8179 
   - totalItems
8180 
   - brand
8181 
   - category
8182 
  """
8183 
 
8184 
  thrift_spec = (
8185 
    None, # 0
8186 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8187 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8188 
    (3, TType.STRING, 'brand', None, None, ), # 3
8189 
    (4, TType.I64, 'category', None, None, ), # 4
8190 
  )
8191 
 
8192 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8193 
    self.beginIndex = beginIndex
8194 
    self.totalItems = totalItems
8195 
    self.brand = brand
8196 
    self.category = category
8197 
 
8198 
  def read(self, iprot):
8199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8201 
      return
8202 
    iprot.readStructBegin()
8203 
    while True:
8204 
      (fname, ftype, fid) = iprot.readFieldBegin()
8205 
      if ftype == TType.STOP:
8206 
        break
8207 
      if fid == 1:
8208 
        if ftype == TType.I64:
8209 
          self.beginIndex = iprot.readI64();
8210 
        else:
8211 
          iprot.skip(ftype)
8212 
      elif fid == 2:
8213 
        if ftype == TType.I64:
8214 
          self.totalItems = iprot.readI64();
8215 
        else:
8216 
          iprot.skip(ftype)
8217 
      elif fid == 3:
8218 
        if ftype == TType.STRING:
8219 
          self.brand = iprot.readString();
8220 
        else:
8221 
          iprot.skip(ftype)
8222 
      elif fid == 4:
8223 
        if ftype == TType.I64:
8224 
          self.category = iprot.readI64();
8225 
        else:
8226 
          iprot.skip(ftype)
8227 
      else:
8228 
        iprot.skip(ftype)
8229 
      iprot.readFieldEnd()
8230 
    iprot.readStructEnd()
8231 
 
8232 
  def write(self, oprot):
8233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8235 
      return
8236 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8237 
    if self.beginIndex is not None:
8238 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8239 
      oprot.writeI64(self.beginIndex)
8240 
      oprot.writeFieldEnd()
8241 
    if self.totalItems is not None:
8242 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8243 
      oprot.writeI64(self.totalItems)
8244 
      oprot.writeFieldEnd()
8245 
    if self.brand is not None:
8246 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8247 
      oprot.writeString(self.brand)
8248 
      oprot.writeFieldEnd()
8249 
    if self.category is not None:
8250 
      oprot.writeFieldBegin('category', TType.I64, 4)
8251 
      oprot.writeI64(self.category)
8252 
      oprot.writeFieldEnd()
8253 
    oprot.writeFieldStop()
8254 
    oprot.writeStructEnd()
8255 
 
8256 
  def validate(self):
8257 
    return
8258 
 
8259 
 
8260 
  def __repr__(self):
8261 
    L = ['%s=%r' % (key, value)
8262 
      for key, value in self.__dict__.iteritems()]
8263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8264 
 
8265 
  def __eq__(self, other):
8266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8267 
 
8268 
  def __ne__(self, other):
8269 
    return not (self == other)
8270 
 
8271 
class getBestDealsCatalogIds_result:
8272 
  """
8273 
  Attributes:
8274 
   - success
8275 
   - cex
8276 
  """
8277 
 
8278 
  thrift_spec = (
8279 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8280 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8281 
  )
8282 
 
8283 
  def __init__(self, success=None, cex=None,):
8284 
    self.success = success
8285 
    self.cex = cex
8286 
 
8287 
  def read(self, iprot):
8288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8290 
      return
8291 
    iprot.readStructBegin()
8292 
    while True:
8293 
      (fname, ftype, fid) = iprot.readFieldBegin()
8294 
      if ftype == TType.STOP:
8295 
        break
8296 
      if fid == 0:
8297 
        if ftype == TType.LIST:
8298 
          self.success = []
7438 amit.gupta 8299 
          (_etype98, _size95) = iprot.readListBegin()
8300 
          for _i99 in xrange(_size95):
8301 
            _elem100 = iprot.readI64();
8302 
            self.success.append(_elem100)
5944 mandeep.dh 8303 
          iprot.readListEnd()
8304 
        else:
8305 
          iprot.skip(ftype)
8306 
      elif fid == 1:
8307 
        if ftype == TType.STRUCT:
8308 
          self.cex = CatalogServiceException()
8309 
          self.cex.read(iprot)
8310 
        else:
8311 
          iprot.skip(ftype)
8312 
      else:
8313 
        iprot.skip(ftype)
8314 
      iprot.readFieldEnd()
8315 
    iprot.readStructEnd()
8316 
 
8317 
  def write(self, oprot):
8318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8320 
      return
8321 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8322 
    if self.success is not None:
8323 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8324 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8325 
      for iter101 in self.success:
8326 
        oprot.writeI64(iter101)
5944 mandeep.dh 8327 
      oprot.writeListEnd()
8328 
      oprot.writeFieldEnd()
8329 
    if self.cex is not None:
8330 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8331 
      self.cex.write(oprot)
8332 
      oprot.writeFieldEnd()
8333 
    oprot.writeFieldStop()
8334 
    oprot.writeStructEnd()
8335 
 
8336 
  def validate(self):
8337 
    return
8338 
 
8339 
 
8340 
  def __repr__(self):
8341 
    L = ['%s=%r' % (key, value)
8342 
      for key, value in self.__dict__.iteritems()]
8343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8344 
 
8345 
  def __eq__(self, other):
8346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8347 
 
8348 
  def __ne__(self, other):
8349 
    return not (self == other)
8350 
 
8351 
class getBestDealsCount_args:
8352 
 
8353 
  thrift_spec = (
8354 
  )
8355 
 
8356 
  def read(self, iprot):
8357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8359 
      return
8360 
    iprot.readStructBegin()
8361 
    while True:
8362 
      (fname, ftype, fid) = iprot.readFieldBegin()
8363 
      if ftype == TType.STOP:
8364 
        break
8365 
      else:
8366 
        iprot.skip(ftype)
8367 
      iprot.readFieldEnd()
8368 
    iprot.readStructEnd()
8369 
 
8370 
  def write(self, oprot):
8371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8373 
      return
8374 
    oprot.writeStructBegin('getBestDealsCount_args')
8375 
    oprot.writeFieldStop()
8376 
    oprot.writeStructEnd()
8377 
 
8378 
  def validate(self):
8379 
    return
8380 
 
8381 
 
8382 
  def __repr__(self):
8383 
    L = ['%s=%r' % (key, value)
8384 
      for key, value in self.__dict__.iteritems()]
8385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8386 
 
8387 
  def __eq__(self, other):
8388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8389 
 
8390 
  def __ne__(self, other):
8391 
    return not (self == other)
8392 
 
8393 
class getBestDealsCount_result:
8394 
  """
8395 
  Attributes:
8396 
   - success
8397 
   - cex
8398 
  """
8399 
 
8400 
  thrift_spec = (
8401 
    (0, TType.I64, 'success', None, None, ), # 0
8402 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8403 
  )
8404 
 
8405 
  def __init__(self, success=None, cex=None,):
8406 
    self.success = success
8407 
    self.cex = cex
8408 
 
8409 
  def read(self, iprot):
8410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8412 
      return
8413 
    iprot.readStructBegin()
8414 
    while True:
8415 
      (fname, ftype, fid) = iprot.readFieldBegin()
8416 
      if ftype == TType.STOP:
8417 
        break
8418 
      if fid == 0:
8419 
        if ftype == TType.I64:
8420 
          self.success = iprot.readI64();
8421 
        else:
8422 
          iprot.skip(ftype)
8423 
      elif fid == 1:
8424 
        if ftype == TType.STRUCT:
8425 
          self.cex = CatalogServiceException()
8426 
          self.cex.read(iprot)
8427 
        else:
8428 
          iprot.skip(ftype)
8429 
      else:
8430 
        iprot.skip(ftype)
8431 
      iprot.readFieldEnd()
8432 
    iprot.readStructEnd()
8433 
 
8434 
  def write(self, oprot):
8435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8437 
      return
8438 
    oprot.writeStructBegin('getBestDealsCount_result')
8439 
    if self.success is not None:
8440 
      oprot.writeFieldBegin('success', TType.I64, 0)
8441 
      oprot.writeI64(self.success)
8442 
      oprot.writeFieldEnd()
8443 
    if self.cex is not None:
8444 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8445 
      self.cex.write(oprot)
8446 
      oprot.writeFieldEnd()
8447 
    oprot.writeFieldStop()
8448 
    oprot.writeStructEnd()
8449 
 
8450 
  def validate(self):
8451 
    return
8452 
 
8453 
 
8454 
  def __repr__(self):
8455 
    L = ['%s=%r' % (key, value)
8456 
      for key, value in self.__dict__.iteritems()]
8457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8458 
 
8459 
  def __eq__(self, other):
8460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8461 
 
8462 
  def __ne__(self, other):
8463 
    return not (self == other)
8464 
 
8465 
class getComingSoon_args:
8466 
 
8467 
  thrift_spec = (
8468 
  )
8469 
 
8470 
  def read(self, iprot):
8471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8473 
      return
8474 
    iprot.readStructBegin()
8475 
    while True:
8476 
      (fname, ftype, fid) = iprot.readFieldBegin()
8477 
      if ftype == TType.STOP:
8478 
        break
8479 
      else:
8480 
        iprot.skip(ftype)
8481 
      iprot.readFieldEnd()
8482 
    iprot.readStructEnd()
8483 
 
8484 
  def write(self, oprot):
8485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8487 
      return
8488 
    oprot.writeStructBegin('getComingSoon_args')
8489 
    oprot.writeFieldStop()
8490 
    oprot.writeStructEnd()
8491 
 
8492 
  def validate(self):
8493 
    return
8494 
 
8495 
 
8496 
  def __repr__(self):
8497 
    L = ['%s=%r' % (key, value)
8498 
      for key, value in self.__dict__.iteritems()]
8499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8500 
 
8501 
  def __eq__(self, other):
8502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8503 
 
8504 
  def __ne__(self, other):
8505 
    return not (self == other)
8506 
 
8507 
class getComingSoon_result:
8508 
  """
8509 
  Attributes:
8510 
   - success
8511 
   - isex
8512 
  """
8513 
 
8514 
  thrift_spec = (
8515 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8516 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8517 
  )
8518 
 
8519 
  def __init__(self, success=None, isex=None,):
8520 
    self.success = success
8521 
    self.isex = isex
8522 
 
8523 
  def read(self, iprot):
8524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8526 
      return
8527 
    iprot.readStructBegin()
8528 
    while True:
8529 
      (fname, ftype, fid) = iprot.readFieldBegin()
8530 
      if ftype == TType.STOP:
8531 
        break
8532 
      if fid == 0:
8533 
        if ftype == TType.LIST:
8534 
          self.success = []
7438 amit.gupta 8535 
          (_etype105, _size102) = iprot.readListBegin()
8536 
          for _i106 in xrange(_size102):
8537 
            _elem107 = Item()
8538 
            _elem107.read(iprot)
8539 
            self.success.append(_elem107)
5944 mandeep.dh 8540 
          iprot.readListEnd()
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 1:
8544 
        if ftype == TType.STRUCT:
8545 
          self.isex = CatalogServiceException()
8546 
          self.isex.read(iprot)
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      else:
8550 
        iprot.skip(ftype)
8551 
      iprot.readFieldEnd()
8552 
    iprot.readStructEnd()
8553 
 
8554 
  def write(self, oprot):
8555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8557 
      return
8558 
    oprot.writeStructBegin('getComingSoon_result')
8559 
    if self.success is not None:
8560 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8561 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8562 
      for iter108 in self.success:
8563 
        iter108.write(oprot)
5944 mandeep.dh 8564 
      oprot.writeListEnd()
8565 
      oprot.writeFieldEnd()
8566 
    if self.isex is not None:
8567 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8568 
      self.isex.write(oprot)
8569 
      oprot.writeFieldEnd()
8570 
    oprot.writeFieldStop()
8571 
    oprot.writeStructEnd()
8572 
 
8573 
  def validate(self):
8574 
    return
8575 
 
8576 
 
8577 
  def __repr__(self):
8578 
    L = ['%s=%r' % (key, value)
8579 
      for key, value in self.__dict__.iteritems()]
8580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8581 
 
8582 
  def __eq__(self, other):
8583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8584 
 
8585 
  def __ne__(self, other):
8586 
    return not (self == other)
8587 
 
8588 
class getComingSoonCatalogIds_args:
8589 
  """
8590 
  Attributes:
8591 
   - beginIndex
8592 
   - totalItems
8593 
   - brand
8594 
   - category
8595 
  """
8596 
 
8597 
  thrift_spec = (
8598 
    None, # 0
8599 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8600 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8601 
    (3, TType.STRING, 'brand', None, None, ), # 3
8602 
    (4, TType.I64, 'category', None, None, ), # 4
8603 
  )
8604 
 
8605 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8606 
    self.beginIndex = beginIndex
8607 
    self.totalItems = totalItems
8608 
    self.brand = brand
8609 
    self.category = category
8610 
 
8611 
  def read(self, iprot):
8612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8614 
      return
8615 
    iprot.readStructBegin()
8616 
    while True:
8617 
      (fname, ftype, fid) = iprot.readFieldBegin()
8618 
      if ftype == TType.STOP:
8619 
        break
8620 
      if fid == 1:
8621 
        if ftype == TType.I64:
8622 
          self.beginIndex = iprot.readI64();
8623 
        else:
8624 
          iprot.skip(ftype)
8625 
      elif fid == 2:
8626 
        if ftype == TType.I64:
8627 
          self.totalItems = iprot.readI64();
8628 
        else:
8629 
          iprot.skip(ftype)
8630 
      elif fid == 3:
8631 
        if ftype == TType.STRING:
8632 
          self.brand = iprot.readString();
8633 
        else:
8634 
          iprot.skip(ftype)
8635 
      elif fid == 4:
8636 
        if ftype == TType.I64:
8637 
          self.category = iprot.readI64();
8638 
        else:
8639 
          iprot.skip(ftype)
8640 
      else:
8641 
        iprot.skip(ftype)
8642 
      iprot.readFieldEnd()
8643 
    iprot.readStructEnd()
8644 
 
8645 
  def write(self, oprot):
8646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8648 
      return
8649 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8650 
    if self.beginIndex is not None:
8651 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8652 
      oprot.writeI64(self.beginIndex)
8653 
      oprot.writeFieldEnd()
8654 
    if self.totalItems is not None:
8655 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8656 
      oprot.writeI64(self.totalItems)
8657 
      oprot.writeFieldEnd()
8658 
    if self.brand is not None:
8659 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8660 
      oprot.writeString(self.brand)
8661 
      oprot.writeFieldEnd()
8662 
    if self.category is not None:
8663 
      oprot.writeFieldBegin('category', TType.I64, 4)
8664 
      oprot.writeI64(self.category)
8665 
      oprot.writeFieldEnd()
8666 
    oprot.writeFieldStop()
8667 
    oprot.writeStructEnd()
8668 
 
8669 
  def validate(self):
8670 
    return
8671 
 
8672 
 
8673 
  def __repr__(self):
8674 
    L = ['%s=%r' % (key, value)
8675 
      for key, value in self.__dict__.iteritems()]
8676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8677 
 
8678 
  def __eq__(self, other):
8679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8680 
 
8681 
  def __ne__(self, other):
8682 
    return not (self == other)
8683 
 
8684 
class getComingSoonCatalogIds_result:
8685 
  """
8686 
  Attributes:
8687 
   - success
8688 
   - cex
8689 
  """
8690 
 
8691 
  thrift_spec = (
8692 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8693 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8694 
  )
8695 
 
8696 
  def __init__(self, success=None, cex=None,):
8697 
    self.success = success
8698 
    self.cex = cex
8699 
 
8700 
  def read(self, iprot):
8701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8703 
      return
8704 
    iprot.readStructBegin()
8705 
    while True:
8706 
      (fname, ftype, fid) = iprot.readFieldBegin()
8707 
      if ftype == TType.STOP:
8708 
        break
8709 
      if fid == 0:
8710 
        if ftype == TType.LIST:
8711 
          self.success = []
7438 amit.gupta 8712 
          (_etype112, _size109) = iprot.readListBegin()
8713 
          for _i113 in xrange(_size109):
8714 
            _elem114 = iprot.readI64();
8715 
            self.success.append(_elem114)
5944 mandeep.dh 8716 
          iprot.readListEnd()
8717 
        else:
8718 
          iprot.skip(ftype)
8719 
      elif fid == 1:
8720 
        if ftype == TType.STRUCT:
8721 
          self.cex = CatalogServiceException()
8722 
          self.cex.read(iprot)
8723 
        else:
8724 
          iprot.skip(ftype)
8725 
      else:
8726 
        iprot.skip(ftype)
8727 
      iprot.readFieldEnd()
8728 
    iprot.readStructEnd()
8729 
 
8730 
  def write(self, oprot):
8731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8733 
      return
8734 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8735 
    if self.success is not None:
8736 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8737 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8738 
      for iter115 in self.success:
8739 
        oprot.writeI64(iter115)
5944 mandeep.dh 8740 
      oprot.writeListEnd()
8741 
      oprot.writeFieldEnd()
8742 
    if self.cex is not None:
8743 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8744 
      self.cex.write(oprot)
8745 
      oprot.writeFieldEnd()
8746 
    oprot.writeFieldStop()
8747 
    oprot.writeStructEnd()
8748 
 
8749 
  def validate(self):
8750 
    return
8751 
 
8752 
 
8753 
  def __repr__(self):
8754 
    L = ['%s=%r' % (key, value)
8755 
      for key, value in self.__dict__.iteritems()]
8756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8757 
 
8758 
  def __eq__(self, other):
8759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8760 
 
8761 
  def __ne__(self, other):
8762 
    return not (self == other)
8763 
 
8764 
class getComingSoonCount_args:
8765 
 
8766 
  thrift_spec = (
8767 
  )
8768 
 
8769 
  def read(self, iprot):
8770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8772 
      return
8773 
    iprot.readStructBegin()
8774 
    while True:
8775 
      (fname, ftype, fid) = iprot.readFieldBegin()
8776 
      if ftype == TType.STOP:
8777 
        break
8778 
      else:
8779 
        iprot.skip(ftype)
8780 
      iprot.readFieldEnd()
8781 
    iprot.readStructEnd()
8782 
 
8783 
  def write(self, oprot):
8784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8786 
      return
8787 
    oprot.writeStructBegin('getComingSoonCount_args')
8788 
    oprot.writeFieldStop()
8789 
    oprot.writeStructEnd()
8790 
 
8791 
  def validate(self):
8792 
    return
8793 
 
8794 
 
8795 
  def __repr__(self):
8796 
    L = ['%s=%r' % (key, value)
8797 
      for key, value in self.__dict__.iteritems()]
8798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8799 
 
8800 
  def __eq__(self, other):
8801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8802 
 
8803 
  def __ne__(self, other):
8804 
    return not (self == other)
8805 
 
8806 
class getComingSoonCount_result:
8807 
  """
8808 
  Attributes:
8809 
   - success
8810 
   - cex
8811 
  """
8812 
 
8813 
  thrift_spec = (
8814 
    (0, TType.I64, 'success', None, None, ), # 0
8815 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8816 
  )
8817 
 
8818 
  def __init__(self, success=None, cex=None,):
8819 
    self.success = success
8820 
    self.cex = cex
8821 
 
8822 
  def read(self, iprot):
8823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8825 
      return
8826 
    iprot.readStructBegin()
8827 
    while True:
8828 
      (fname, ftype, fid) = iprot.readFieldBegin()
8829 
      if ftype == TType.STOP:
8830 
        break
8831 
      if fid == 0:
8832 
        if ftype == TType.I64:
8833 
          self.success = iprot.readI64();
8834 
        else:
8835 
          iprot.skip(ftype)
8836 
      elif fid == 1:
8837 
        if ftype == TType.STRUCT:
8838 
          self.cex = CatalogServiceException()
8839 
          self.cex.read(iprot)
8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      else:
8843 
        iprot.skip(ftype)
8844 
      iprot.readFieldEnd()
8845 
    iprot.readStructEnd()
8846 
 
8847 
  def write(self, oprot):
8848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8850 
      return
8851 
    oprot.writeStructBegin('getComingSoonCount_result')
8852 
    if self.success is not None:
8853 
      oprot.writeFieldBegin('success', TType.I64, 0)
8854 
      oprot.writeI64(self.success)
8855 
      oprot.writeFieldEnd()
8856 
    if self.cex is not None:
8857 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8858 
      self.cex.write(oprot)
8859 
      oprot.writeFieldEnd()
8860 
    oprot.writeFieldStop()
8861 
    oprot.writeStructEnd()
8862 
 
8863 
  def validate(self):
8864 
    return
8865 
 
8866 
 
8867 
  def __repr__(self):
8868 
    L = ['%s=%r' % (key, value)
8869 
      for key, value in self.__dict__.iteritems()]
8870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8871 
 
8872 
  def __eq__(self, other):
8873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8874 
 
8875 
  def __ne__(self, other):
8876 
    return not (self == other)
8877 
 
8878 
class getLatestArrivals_args:
8879 
 
8880 
  thrift_spec = (
8881 
  )
8882 
 
8883 
  def read(self, iprot):
8884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8886 
      return
8887 
    iprot.readStructBegin()
8888 
    while True:
8889 
      (fname, ftype, fid) = iprot.readFieldBegin()
8890 
      if ftype == TType.STOP:
8891 
        break
8892 
      else:
8893 
        iprot.skip(ftype)
8894 
      iprot.readFieldEnd()
8895 
    iprot.readStructEnd()
8896 
 
8897 
  def write(self, oprot):
8898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8900 
      return
8901 
    oprot.writeStructBegin('getLatestArrivals_args')
8902 
    oprot.writeFieldStop()
8903 
    oprot.writeStructEnd()
8904 
 
8905 
  def validate(self):
8906 
    return
8907 
 
8908 
 
8909 
  def __repr__(self):
8910 
    L = ['%s=%r' % (key, value)
8911 
      for key, value in self.__dict__.iteritems()]
8912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8913 
 
8914 
  def __eq__(self, other):
8915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8916 
 
8917 
  def __ne__(self, other):
8918 
    return not (self == other)
8919 
 
8920 
class getLatestArrivals_result:
8921 
  """
8922 
  Attributes:
8923 
   - success
8924 
   - isex
8925 
  """
8926 
 
8927 
  thrift_spec = (
8928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8929 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8930 
  )
8931 
 
8932 
  def __init__(self, success=None, isex=None,):
8933 
    self.success = success
8934 
    self.isex = isex
8935 
 
8936 
  def read(self, iprot):
8937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8939 
      return
8940 
    iprot.readStructBegin()
8941 
    while True:
8942 
      (fname, ftype, fid) = iprot.readFieldBegin()
8943 
      if ftype == TType.STOP:
8944 
        break
8945 
      if fid == 0:
8946 
        if ftype == TType.LIST:
8947 
          self.success = []
7438 amit.gupta 8948 
          (_etype119, _size116) = iprot.readListBegin()
8949 
          for _i120 in xrange(_size116):
8950 
            _elem121 = Item()
8951 
            _elem121.read(iprot)
8952 
            self.success.append(_elem121)
5944 mandeep.dh 8953 
          iprot.readListEnd()
8954 
        else:
8955 
          iprot.skip(ftype)
8956 
      elif fid == 1:
8957 
        if ftype == TType.STRUCT:
8958 
          self.isex = CatalogServiceException()
8959 
          self.isex.read(iprot)
8960 
        else:
8961 
          iprot.skip(ftype)
8962 
      else:
8963 
        iprot.skip(ftype)
8964 
      iprot.readFieldEnd()
8965 
    iprot.readStructEnd()
8966 
 
8967 
  def write(self, oprot):
8968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8970 
      return
8971 
    oprot.writeStructBegin('getLatestArrivals_result')
8972 
    if self.success is not None:
8973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8974 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8975 
      for iter122 in self.success:
8976 
        iter122.write(oprot)
5944 mandeep.dh 8977 
      oprot.writeListEnd()
8978 
      oprot.writeFieldEnd()
8979 
    if self.isex is not None:
8980 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8981 
      self.isex.write(oprot)
8982 
      oprot.writeFieldEnd()
8983 
    oprot.writeFieldStop()
8984 
    oprot.writeStructEnd()
8985 
 
8986 
  def validate(self):
8987 
    return
8988 
 
8989 
 
8990 
  def __repr__(self):
8991 
    L = ['%s=%r' % (key, value)
8992 
      for key, value in self.__dict__.iteritems()]
8993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8994 
 
8995 
  def __eq__(self, other):
8996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8997 
 
8998 
  def __ne__(self, other):
8999 
    return not (self == other)
9000 
 
9001 
class getLatestArrivalsCatalogIds_args:
9002 
  """
9003 
  Attributes:
9004 
   - beginIndex
9005 
   - totalItems
9006 
   - brand
9007 
   - categories
9008 
  """
9009 
 
9010 
  thrift_spec = (
9011 
    None, # 0
9012 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9013 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9014 
    (3, TType.STRING, 'brand', None, None, ), # 3
9015 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9016 
  )
9017 
 
9018 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9019 
    self.beginIndex = beginIndex
9020 
    self.totalItems = totalItems
9021 
    self.brand = brand
9022 
    self.categories = categories
9023 
 
9024 
  def read(self, iprot):
9025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9027 
      return
9028 
    iprot.readStructBegin()
9029 
    while True:
9030 
      (fname, ftype, fid) = iprot.readFieldBegin()
9031 
      if ftype == TType.STOP:
9032 
        break
9033 
      if fid == 1:
9034 
        if ftype == TType.I64:
9035 
          self.beginIndex = iprot.readI64();
9036 
        else:
9037 
          iprot.skip(ftype)
9038 
      elif fid == 2:
9039 
        if ftype == TType.I64:
9040 
          self.totalItems = iprot.readI64();
9041 
        else:
9042 
          iprot.skip(ftype)
9043 
      elif fid == 3:
9044 
        if ftype == TType.STRING:
9045 
          self.brand = iprot.readString();
9046 
        else:
9047 
          iprot.skip(ftype)
9048 
      elif fid == 4:
9049 
        if ftype == TType.LIST:
9050 
          self.categories = []
7438 amit.gupta 9051 
          (_etype126, _size123) = iprot.readListBegin()
9052 
          for _i127 in xrange(_size123):
9053 
            _elem128 = iprot.readI64();
9054 
            self.categories.append(_elem128)
5944 mandeep.dh 9055 
          iprot.readListEnd()
9056 
        else:
9057 
          iprot.skip(ftype)
9058 
      else:
9059 
        iprot.skip(ftype)
9060 
      iprot.readFieldEnd()
9061 
    iprot.readStructEnd()
9062 
 
9063 
  def write(self, oprot):
9064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9066 
      return
9067 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9068 
    if self.beginIndex is not None:
9069 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9070 
      oprot.writeI64(self.beginIndex)
9071 
      oprot.writeFieldEnd()
9072 
    if self.totalItems is not None:
9073 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9074 
      oprot.writeI64(self.totalItems)
9075 
      oprot.writeFieldEnd()
9076 
    if self.brand is not None:
9077 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9078 
      oprot.writeString(self.brand)
9079 
      oprot.writeFieldEnd()
9080 
    if self.categories is not None:
9081 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9082 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9083 
      for iter129 in self.categories:
9084 
        oprot.writeI64(iter129)
5944 mandeep.dh 9085 
      oprot.writeListEnd()
9086 
      oprot.writeFieldEnd()
9087 
    oprot.writeFieldStop()
9088 
    oprot.writeStructEnd()
9089 
 
9090 
  def validate(self):
9091 
    return
9092 
 
9093 
 
9094 
  def __repr__(self):
9095 
    L = ['%s=%r' % (key, value)
9096 
      for key, value in self.__dict__.iteritems()]
9097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9098 
 
9099 
  def __eq__(self, other):
9100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9101 
 
9102 
  def __ne__(self, other):
9103 
    return not (self == other)
9104 
 
9105 
class getLatestArrivalsCatalogIds_result:
9106 
  """
9107 
  Attributes:
9108 
   - success
9109 
   - cex
9110 
  """
9111 
 
9112 
  thrift_spec = (
9113 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9114 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9115 
  )
9116 
 
9117 
  def __init__(self, success=None, cex=None,):
9118 
    self.success = success
9119 
    self.cex = cex
9120 
 
9121 
  def read(self, iprot):
9122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9124 
      return
9125 
    iprot.readStructBegin()
9126 
    while True:
9127 
      (fname, ftype, fid) = iprot.readFieldBegin()
9128 
      if ftype == TType.STOP:
9129 
        break
9130 
      if fid == 0:
9131 
        if ftype == TType.LIST:
9132 
          self.success = []
7438 amit.gupta 9133 
          (_etype133, _size130) = iprot.readListBegin()
9134 
          for _i134 in xrange(_size130):
9135 
            _elem135 = iprot.readI64();
9136 
            self.success.append(_elem135)
5944 mandeep.dh 9137 
          iprot.readListEnd()
9138 
        else:
9139 
          iprot.skip(ftype)
9140 
      elif fid == 1:
9141 
        if ftype == TType.STRUCT:
9142 
          self.cex = CatalogServiceException()
9143 
          self.cex.read(iprot)
9144 
        else:
9145 
          iprot.skip(ftype)
9146 
      else:
9147 
        iprot.skip(ftype)
9148 
      iprot.readFieldEnd()
9149 
    iprot.readStructEnd()
9150 
 
9151 
  def write(self, oprot):
9152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9154 
      return
9155 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9156 
    if self.success is not None:
9157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9158 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9159 
      for iter136 in self.success:
9160 
        oprot.writeI64(iter136)
5944 mandeep.dh 9161 
      oprot.writeListEnd()
9162 
      oprot.writeFieldEnd()
9163 
    if self.cex is not None:
9164 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9165 
      self.cex.write(oprot)
9166 
      oprot.writeFieldEnd()
9167 
    oprot.writeFieldStop()
9168 
    oprot.writeStructEnd()
9169 
 
9170 
  def validate(self):
9171 
    return
9172 
 
9173 
 
9174 
  def __repr__(self):
9175 
    L = ['%s=%r' % (key, value)
9176 
      for key, value in self.__dict__.iteritems()]
9177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9178 
 
9179 
  def __eq__(self, other):
9180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9181 
 
9182 
  def __ne__(self, other):
9183 
    return not (self == other)
9184 
 
9185 
class getLatestArrivalsCount_args:
9186 
 
9187 
  thrift_spec = (
9188 
  )
9189 
 
9190 
  def read(self, iprot):
9191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9193 
      return
9194 
    iprot.readStructBegin()
9195 
    while True:
9196 
      (fname, ftype, fid) = iprot.readFieldBegin()
9197 
      if ftype == TType.STOP:
9198 
        break
9199 
      else:
9200 
        iprot.skip(ftype)
9201 
      iprot.readFieldEnd()
9202 
    iprot.readStructEnd()
9203 
 
9204 
  def write(self, oprot):
9205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9207 
      return
9208 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9209 
    oprot.writeFieldStop()
9210 
    oprot.writeStructEnd()
9211 
 
9212 
  def validate(self):
9213 
    return
9214 
 
9215 
 
9216 
  def __repr__(self):
9217 
    L = ['%s=%r' % (key, value)
9218 
      for key, value in self.__dict__.iteritems()]
9219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9220 
 
9221 
  def __eq__(self, other):
9222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9223 
 
9224 
  def __ne__(self, other):
9225 
    return not (self == other)
9226 
 
9227 
class getLatestArrivalsCount_result:
9228 
  """
9229 
  Attributes:
9230 
   - success
9231 
   - cex
9232 
  """
9233 
 
9234 
  thrift_spec = (
9235 
    (0, TType.I64, 'success', None, None, ), # 0
9236 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9237 
  )
9238 
 
9239 
  def __init__(self, success=None, cex=None,):
9240 
    self.success = success
9241 
    self.cex = cex
9242 
 
9243 
  def read(self, iprot):
9244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9246 
      return
9247 
    iprot.readStructBegin()
9248 
    while True:
9249 
      (fname, ftype, fid) = iprot.readFieldBegin()
9250 
      if ftype == TType.STOP:
9251 
        break
9252 
      if fid == 0:
9253 
        if ftype == TType.I64:
9254 
          self.success = iprot.readI64();
9255 
        else:
9256 
          iprot.skip(ftype)
9257 
      elif fid == 1:
9258 
        if ftype == TType.STRUCT:
9259 
          self.cex = CatalogServiceException()
9260 
          self.cex.read(iprot)
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      else:
9264 
        iprot.skip(ftype)
9265 
      iprot.readFieldEnd()
9266 
    iprot.readStructEnd()
9267 
 
9268 
  def write(self, oprot):
9269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9271 
      return
9272 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9273 
    if self.success is not None:
9274 
      oprot.writeFieldBegin('success', TType.I64, 0)
9275 
      oprot.writeI64(self.success)
9276 
      oprot.writeFieldEnd()
9277 
    if self.cex is not None:
9278 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9279 
      self.cex.write(oprot)
9280 
      oprot.writeFieldEnd()
9281 
    oprot.writeFieldStop()
9282 
    oprot.writeStructEnd()
9283 
 
9284 
  def validate(self):
9285 
    return
9286 
 
9287 
 
9288 
  def __repr__(self):
9289 
    L = ['%s=%r' % (key, value)
9290 
      for key, value in self.__dict__.iteritems()]
9291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9292 
 
9293 
  def __eq__(self, other):
9294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9295 
 
9296 
  def __ne__(self, other):
9297 
    return not (self == other)
9298 
 
9299 
class generateNewEntityID_args:
9300 
 
9301 
  thrift_spec = (
9302 
  )
9303 
 
9304 
  def read(self, iprot):
9305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9307 
      return
9308 
    iprot.readStructBegin()
9309 
    while True:
9310 
      (fname, ftype, fid) = iprot.readFieldBegin()
9311 
      if ftype == TType.STOP:
9312 
        break
9313 
      else:
9314 
        iprot.skip(ftype)
9315 
      iprot.readFieldEnd()
9316 
    iprot.readStructEnd()
9317 
 
9318 
  def write(self, oprot):
9319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9321 
      return
9322 
    oprot.writeStructBegin('generateNewEntityID_args')
9323 
    oprot.writeFieldStop()
9324 
    oprot.writeStructEnd()
9325 
 
9326 
  def validate(self):
9327 
    return
9328 
 
9329 
 
9330 
  def __repr__(self):
9331 
    L = ['%s=%r' % (key, value)
9332 
      for key, value in self.__dict__.iteritems()]
9333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9334 
 
9335 
  def __eq__(self, other):
9336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9337 
 
9338 
  def __ne__(self, other):
9339 
    return not (self == other)
9340 
 
9341 
class generateNewEntityID_result:
9342 
  """
9343 
  Attributes:
9344 
   - success
9345 
  """
9346 
 
9347 
  thrift_spec = (
9348 
    (0, TType.I64, 'success', None, None, ), # 0
9349 
  )
9350 
 
9351 
  def __init__(self, success=None,):
9352 
    self.success = success
9353 
 
9354 
  def read(self, iprot):
9355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9357 
      return
9358 
    iprot.readStructBegin()
9359 
    while True:
9360 
      (fname, ftype, fid) = iprot.readFieldBegin()
9361 
      if ftype == TType.STOP:
9362 
        break
9363 
      if fid == 0:
9364 
        if ftype == TType.I64:
9365 
          self.success = iprot.readI64();
9366 
        else:
9367 
          iprot.skip(ftype)
9368 
      else:
9369 
        iprot.skip(ftype)
9370 
      iprot.readFieldEnd()
9371 
    iprot.readStructEnd()
9372 
 
9373 
  def write(self, oprot):
9374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9376 
      return
9377 
    oprot.writeStructBegin('generateNewEntityID_result')
9378 
    if self.success is not None:
9379 
      oprot.writeFieldBegin('success', TType.I64, 0)
9380 
      oprot.writeI64(self.success)
9381 
      oprot.writeFieldEnd()
9382 
    oprot.writeFieldStop()
9383 
    oprot.writeStructEnd()
9384 
 
9385 
  def validate(self):
9386 
    return
9387 
 
9388 
 
9389 
  def __repr__(self):
9390 
    L = ['%s=%r' % (key, value)
9391 
      for key, value in self.__dict__.iteritems()]
9392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9393 
 
9394 
  def __eq__(self, other):
9395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9396 
 
9397 
  def __ne__(self, other):
9398 
    return not (self == other)
9399 
 
9400 
class addCategory_args:
9401 
  """
9402 
  Attributes:
9403 
   - category
9404 
  """
9405 
 
9406 
  thrift_spec = (
9407 
    None, # 0
9408 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9409 
  )
9410 
 
9411 
  def __init__(self, category=None,):
9412 
    self.category = category
9413 
 
9414 
  def read(self, iprot):
9415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9417 
      return
9418 
    iprot.readStructBegin()
9419 
    while True:
9420 
      (fname, ftype, fid) = iprot.readFieldBegin()
9421 
      if ftype == TType.STOP:
9422 
        break
9423 
      if fid == 1:
9424 
        if ftype == TType.STRUCT:
9425 
          self.category = Category()
9426 
          self.category.read(iprot)
9427 
        else:
9428 
          iprot.skip(ftype)
9429 
      else:
9430 
        iprot.skip(ftype)
9431 
      iprot.readFieldEnd()
9432 
    iprot.readStructEnd()
9433 
 
9434 
  def write(self, oprot):
9435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9437 
      return
9438 
    oprot.writeStructBegin('addCategory_args')
9439 
    if self.category is not None:
9440 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9441 
      self.category.write(oprot)
9442 
      oprot.writeFieldEnd()
9443 
    oprot.writeFieldStop()
9444 
    oprot.writeStructEnd()
9445 
 
9446 
  def validate(self):
9447 
    return
9448 
 
9449 
 
9450 
  def __repr__(self):
9451 
    L = ['%s=%r' % (key, value)
9452 
      for key, value in self.__dict__.iteritems()]
9453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9454 
 
9455 
  def __eq__(self, other):
9456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9457 
 
9458 
  def __ne__(self, other):
9459 
    return not (self == other)
9460 
 
9461 
class addCategory_result:
9462 
  """
9463 
  Attributes:
9464 
   - success
9465 
  """
9466 
 
9467 
  thrift_spec = (
9468 
    (0, TType.BOOL, 'success', None, None, ), # 0
9469 
  )
9470 
 
9471 
  def __init__(self, success=None,):
9472 
    self.success = success
9473 
 
9474 
  def read(self, iprot):
9475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9477 
      return
9478 
    iprot.readStructBegin()
9479 
    while True:
9480 
      (fname, ftype, fid) = iprot.readFieldBegin()
9481 
      if ftype == TType.STOP:
9482 
        break
9483 
      if fid == 0:
9484 
        if ftype == TType.BOOL:
9485 
          self.success = iprot.readBool();
9486 
        else:
9487 
          iprot.skip(ftype)
9488 
      else:
9489 
        iprot.skip(ftype)
9490 
      iprot.readFieldEnd()
9491 
    iprot.readStructEnd()
9492 
 
9493 
  def write(self, oprot):
9494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9496 
      return
9497 
    oprot.writeStructBegin('addCategory_result')
9498 
    if self.success is not None:
9499 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9500 
      oprot.writeBool(self.success)
9501 
      oprot.writeFieldEnd()
9502 
    oprot.writeFieldStop()
9503 
    oprot.writeStructEnd()
9504 
 
9505 
  def validate(self):
9506 
    return
9507 
 
9508 
 
9509 
  def __repr__(self):
9510 
    L = ['%s=%r' % (key, value)
9511 
      for key, value in self.__dict__.iteritems()]
9512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9513 
 
9514 
  def __eq__(self, other):
9515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9516 
 
9517 
  def __ne__(self, other):
9518 
    return not (self == other)
9519 
 
9520 
class getCategory_args:
9521 
  """
9522 
  Attributes:
9523 
   - id
9524 
  """
9525 
 
9526 
  thrift_spec = (
9527 
    None, # 0
9528 
    (1, TType.I64, 'id', None, None, ), # 1
9529 
  )
9530 
 
9531 
  def __init__(self, id=None,):
9532 
    self.id = id
9533 
 
9534 
  def read(self, iprot):
9535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9537 
      return
9538 
    iprot.readStructBegin()
9539 
    while True:
9540 
      (fname, ftype, fid) = iprot.readFieldBegin()
9541 
      if ftype == TType.STOP:
9542 
        break
9543 
      if fid == 1:
9544 
        if ftype == TType.I64:
9545 
          self.id = iprot.readI64();
9546 
        else:
9547 
          iprot.skip(ftype)
9548 
      else:
9549 
        iprot.skip(ftype)
9550 
      iprot.readFieldEnd()
9551 
    iprot.readStructEnd()
9552 
 
9553 
  def write(self, oprot):
9554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9556 
      return
9557 
    oprot.writeStructBegin('getCategory_args')
9558 
    if self.id is not None:
9559 
      oprot.writeFieldBegin('id', TType.I64, 1)
9560 
      oprot.writeI64(self.id)
9561 
      oprot.writeFieldEnd()
9562 
    oprot.writeFieldStop()
9563 
    oprot.writeStructEnd()
9564 
 
9565 
  def validate(self):
9566 
    return
9567 
 
9568 
 
9569 
  def __repr__(self):
9570 
    L = ['%s=%r' % (key, value)
9571 
      for key, value in self.__dict__.iteritems()]
9572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9573 
 
9574 
  def __eq__(self, other):
9575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9576 
 
9577 
  def __ne__(self, other):
9578 
    return not (self == other)
9579 
 
9580 
class getCategory_result:
9581 
  """
9582 
  Attributes:
9583 
   - success
9584 
  """
9585 
 
9586 
  thrift_spec = (
9587 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9588 
  )
9589 
 
9590 
  def __init__(self, success=None,):
9591 
    self.success = success
9592 
 
9593 
  def read(self, iprot):
9594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9596 
      return
9597 
    iprot.readStructBegin()
9598 
    while True:
9599 
      (fname, ftype, fid) = iprot.readFieldBegin()
9600 
      if ftype == TType.STOP:
9601 
        break
9602 
      if fid == 0:
9603 
        if ftype == TType.STRUCT:
9604 
          self.success = Category()
9605 
          self.success.read(iprot)
9606 
        else:
9607 
          iprot.skip(ftype)
9608 
      else:
9609 
        iprot.skip(ftype)
9610 
      iprot.readFieldEnd()
9611 
    iprot.readStructEnd()
9612 
 
9613 
  def write(self, oprot):
9614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9616 
      return
9617 
    oprot.writeStructBegin('getCategory_result')
9618 
    if self.success is not None:
9619 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9620 
      self.success.write(oprot)
9621 
      oprot.writeFieldEnd()
9622 
    oprot.writeFieldStop()
9623 
    oprot.writeStructEnd()
9624 
 
9625 
  def validate(self):
9626 
    return
9627 
 
9628 
 
9629 
  def __repr__(self):
9630 
    L = ['%s=%r' % (key, value)
9631 
      for key, value in self.__dict__.iteritems()]
9632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9633 
 
9634 
  def __eq__(self, other):
9635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9636 
 
9637 
  def __ne__(self, other):
9638 
    return not (self == other)
9639 
 
9640 
class getAllCategories_args:
9641 
 
9642 
  thrift_spec = (
9643 
  )
9644 
 
9645 
  def read(self, iprot):
9646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9648 
      return
9649 
    iprot.readStructBegin()
9650 
    while True:
9651 
      (fname, ftype, fid) = iprot.readFieldBegin()
9652 
      if ftype == TType.STOP:
9653 
        break
9654 
      else:
9655 
        iprot.skip(ftype)
9656 
      iprot.readFieldEnd()
9657 
    iprot.readStructEnd()
9658 
 
9659 
  def write(self, oprot):
9660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9662 
      return
9663 
    oprot.writeStructBegin('getAllCategories_args')
9664 
    oprot.writeFieldStop()
9665 
    oprot.writeStructEnd()
9666 
 
9667 
  def validate(self):
9668 
    return
9669 
 
9670 
 
9671 
  def __repr__(self):
9672 
    L = ['%s=%r' % (key, value)
9673 
      for key, value in self.__dict__.iteritems()]
9674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9675 
 
9676 
  def __eq__(self, other):
9677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9678 
 
9679 
  def __ne__(self, other):
9680 
    return not (self == other)
9681 
 
9682 
class getAllCategories_result:
9683 
  """
9684 
  Attributes:
9685 
   - success
9686 
  """
9687 
 
9688 
  thrift_spec = (
9689 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9690 
  )
9691 
 
9692 
  def __init__(self, success=None,):
9693 
    self.success = success
9694 
 
9695 
  def read(self, iprot):
9696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9698 
      return
9699 
    iprot.readStructBegin()
9700 
    while True:
9701 
      (fname, ftype, fid) = iprot.readFieldBegin()
9702 
      if ftype == TType.STOP:
9703 
        break
9704 
      if fid == 0:
9705 
        if ftype == TType.LIST:
9706 
          self.success = []
7438 amit.gupta 9707 
          (_etype140, _size137) = iprot.readListBegin()
9708 
          for _i141 in xrange(_size137):
9709 
            _elem142 = Category()
9710 
            _elem142.read(iprot)
9711 
            self.success.append(_elem142)
5944 mandeep.dh 9712 
          iprot.readListEnd()
9713 
        else:
9714 
          iprot.skip(ftype)
9715 
      else:
9716 
        iprot.skip(ftype)
9717 
      iprot.readFieldEnd()
9718 
    iprot.readStructEnd()
9719 
 
9720 
  def write(self, oprot):
9721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9723 
      return
9724 
    oprot.writeStructBegin('getAllCategories_result')
9725 
    if self.success is not None:
9726 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9727 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9728 
      for iter143 in self.success:
9729 
        iter143.write(oprot)
5944 mandeep.dh 9730 
      oprot.writeListEnd()
9731 
      oprot.writeFieldEnd()
9732 
    oprot.writeFieldStop()
9733 
    oprot.writeStructEnd()
9734 
 
9735 
  def validate(self):
9736 
    return
9737 
 
9738 
 
9739 
  def __repr__(self):
9740 
    L = ['%s=%r' % (key, value)
9741 
      for key, value in self.__dict__.iteritems()]
9742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9743 
 
9744 
  def __eq__(self, other):
9745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9746 
 
9747 
  def __ne__(self, other):
9748 
    return not (self == other)
9749 
 
9750 
class getAllSimilarItems_args:
9751 
  """
9752 
  Attributes:
9753 
   - itemId
9754 
  """
9755 
 
9756 
  thrift_spec = (
9757 
    None, # 0
9758 
    (1, TType.I64, 'itemId', None, None, ), # 1
9759 
  )
9760 
 
9761 
  def __init__(self, itemId=None,):
9762 
    self.itemId = itemId
9763 
 
9764 
  def read(self, iprot):
9765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9767 
      return
9768 
    iprot.readStructBegin()
9769 
    while True:
9770 
      (fname, ftype, fid) = iprot.readFieldBegin()
9771 
      if ftype == TType.STOP:
9772 
        break
9773 
      if fid == 1:
9774 
        if ftype == TType.I64:
9775 
          self.itemId = iprot.readI64();
9776 
        else:
9777 
          iprot.skip(ftype)
9778 
      else:
9779 
        iprot.skip(ftype)
9780 
      iprot.readFieldEnd()
9781 
    iprot.readStructEnd()
9782 
 
9783 
  def write(self, oprot):
9784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9786 
      return
9787 
    oprot.writeStructBegin('getAllSimilarItems_args')
9788 
    if self.itemId is not None:
9789 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9790 
      oprot.writeI64(self.itemId)
9791 
      oprot.writeFieldEnd()
9792 
    oprot.writeFieldStop()
9793 
    oprot.writeStructEnd()
9794 
 
9795 
  def validate(self):
9796 
    return
9797 
 
9798 
 
9799 
  def __repr__(self):
9800 
    L = ['%s=%r' % (key, value)
9801 
      for key, value in self.__dict__.iteritems()]
9802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9803 
 
9804 
  def __eq__(self, other):
9805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9806 
 
9807 
  def __ne__(self, other):
9808 
    return not (self == other)
9809 
 
9810 
class getAllSimilarItems_result:
9811 
  """
9812 
  Attributes:
9813 
   - success
9814 
  """
9815 
 
9816 
  thrift_spec = (
9817 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9818 
  )
9819 
 
9820 
  def __init__(self, success=None,):
9821 
    self.success = success
9822 
 
9823 
  def read(self, iprot):
9824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9826 
      return
9827 
    iprot.readStructBegin()
9828 
    while True:
9829 
      (fname, ftype, fid) = iprot.readFieldBegin()
9830 
      if ftype == TType.STOP:
9831 
        break
9832 
      if fid == 0:
9833 
        if ftype == TType.LIST:
9834 
          self.success = []
7438 amit.gupta 9835 
          (_etype147, _size144) = iprot.readListBegin()
9836 
          for _i148 in xrange(_size144):
9837 
            _elem149 = Item()
9838 
            _elem149.read(iprot)
9839 
            self.success.append(_elem149)
5944 mandeep.dh 9840 
          iprot.readListEnd()
9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      else:
9844 
        iprot.skip(ftype)
9845 
      iprot.readFieldEnd()
9846 
    iprot.readStructEnd()
9847 
 
9848 
  def write(self, oprot):
9849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9851 
      return
9852 
    oprot.writeStructBegin('getAllSimilarItems_result')
9853 
    if self.success is not None:
9854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9855 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9856 
      for iter150 in self.success:
9857 
        iter150.write(oprot)
5944 mandeep.dh 9858 
      oprot.writeListEnd()
9859 
      oprot.writeFieldEnd()
9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
9863 
  def validate(self):
9864 
    return
9865 
 
9866 
 
9867 
  def __repr__(self):
9868 
    L = ['%s=%r' % (key, value)
9869 
      for key, value in self.__dict__.iteritems()]
9870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9871 
 
9872 
  def __eq__(self, other):
9873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9874 
 
9875 
  def __ne__(self, other):
9876 
    return not (self == other)
9877 
 
9878 
class addSimilarItem_args:
9879 
  """
9880 
  Attributes:
9881 
   - itemId
9882 
   - catalogItemId
9883 
  """
9884 
 
9885 
  thrift_spec = (
9886 
    None, # 0
9887 
    (1, TType.I64, 'itemId', None, None, ), # 1
9888 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9889 
  )
9890 
 
9891 
  def __init__(self, itemId=None, catalogItemId=None,):
9892 
    self.itemId = itemId
9893 
    self.catalogItemId = catalogItemId
9894 
 
9895 
  def read(self, iprot):
9896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9898 
      return
9899 
    iprot.readStructBegin()
9900 
    while True:
9901 
      (fname, ftype, fid) = iprot.readFieldBegin()
9902 
      if ftype == TType.STOP:
9903 
        break
9904 
      if fid == 1:
9905 
        if ftype == TType.I64:
9906 
          self.itemId = iprot.readI64();
9907 
        else:
9908 
          iprot.skip(ftype)
9909 
      elif fid == 2:
9910 
        if ftype == TType.I64:
9911 
          self.catalogItemId = iprot.readI64();
9912 
        else:
9913 
          iprot.skip(ftype)
9914 
      else:
9915 
        iprot.skip(ftype)
9916 
      iprot.readFieldEnd()
9917 
    iprot.readStructEnd()
9918 
 
9919 
  def write(self, oprot):
9920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9922 
      return
9923 
    oprot.writeStructBegin('addSimilarItem_args')
9924 
    if self.itemId is not None:
9925 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9926 
      oprot.writeI64(self.itemId)
9927 
      oprot.writeFieldEnd()
9928 
    if self.catalogItemId is not None:
9929 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9930 
      oprot.writeI64(self.catalogItemId)
9931 
      oprot.writeFieldEnd()
9932 
    oprot.writeFieldStop()
9933 
    oprot.writeStructEnd()
9934 
 
9935 
  def validate(self):
9936 
    return
9937 
 
9938 
 
9939 
  def __repr__(self):
9940 
    L = ['%s=%r' % (key, value)
9941 
      for key, value in self.__dict__.iteritems()]
9942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9943 
 
9944 
  def __eq__(self, other):
9945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9946 
 
9947 
  def __ne__(self, other):
9948 
    return not (self == other)
9949 
 
9950 
class addSimilarItem_result:
9951 
  """
9952 
  Attributes:
9953 
   - success
9954 
   - cex
9955 
  """
9956 
 
9957 
  thrift_spec = (
9958 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9959 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9960 
  )
9961 
 
9962 
  def __init__(self, success=None, cex=None,):
9963 
    self.success = success
9964 
    self.cex = cex
9965 
 
9966 
  def read(self, iprot):
9967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9969 
      return
9970 
    iprot.readStructBegin()
9971 
    while True:
9972 
      (fname, ftype, fid) = iprot.readFieldBegin()
9973 
      if ftype == TType.STOP:
9974 
        break
9975 
      if fid == 0:
9976 
        if ftype == TType.STRUCT:
9977 
          self.success = Item()
9978 
          self.success.read(iprot)
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      elif fid == 1:
9982 
        if ftype == TType.STRUCT:
9983 
          self.cex = CatalogServiceException()
9984 
          self.cex.read(iprot)
9985 
        else:
9986 
          iprot.skip(ftype)
9987 
      else:
9988 
        iprot.skip(ftype)
9989 
      iprot.readFieldEnd()
9990 
    iprot.readStructEnd()
9991 
 
9992 
  def write(self, oprot):
9993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9995 
      return
9996 
    oprot.writeStructBegin('addSimilarItem_result')
9997 
    if self.success is not None:
9998 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9999 
      self.success.write(oprot)
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 
 
6512 kshitij.so 10023 
class addTag_args:
10024 
  """
10025 
  Attributes:
10026 
   - displayName
10027 
   - itemId
10028 
  """
10029 
 
10030 
  thrift_spec = (
10031 
    None, # 0
10032 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10033 
    (2, TType.I64, 'itemId', None, None, ), # 2
10034 
  )
10035 
 
10036 
  def __init__(self, displayName=None, itemId=None,):
10037 
    self.displayName = displayName
10038 
    self.itemId = itemId
10039 
 
10040 
  def read(self, iprot):
10041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10043 
      return
10044 
    iprot.readStructBegin()
10045 
    while True:
10046 
      (fname, ftype, fid) = iprot.readFieldBegin()
10047 
      if ftype == TType.STOP:
10048 
        break
10049 
      if fid == 1:
10050 
        if ftype == TType.STRING:
10051 
          self.displayName = iprot.readString();
10052 
        else:
10053 
          iprot.skip(ftype)
10054 
      elif fid == 2:
10055 
        if ftype == TType.I64:
10056 
          self.itemId = iprot.readI64();
10057 
        else:
10058 
          iprot.skip(ftype)
10059 
      else:
10060 
        iprot.skip(ftype)
10061 
      iprot.readFieldEnd()
10062 
    iprot.readStructEnd()
10063 
 
10064 
  def write(self, oprot):
10065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10067 
      return
10068 
    oprot.writeStructBegin('addTag_args')
10069 
    if self.displayName is not None:
10070 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10071 
      oprot.writeString(self.displayName)
10072 
      oprot.writeFieldEnd()
10073 
    if self.itemId is not None:
10074 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10075 
      oprot.writeI64(self.itemId)
10076 
      oprot.writeFieldEnd()
10077 
    oprot.writeFieldStop()
10078 
    oprot.writeStructEnd()
10079 
 
10080 
  def validate(self):
10081 
    return
10082 
 
10083 
 
10084 
  def __repr__(self):
10085 
    L = ['%s=%r' % (key, value)
10086 
      for key, value in self.__dict__.iteritems()]
10087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10088 
 
10089 
  def __eq__(self, other):
10090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10091 
 
10092 
  def __ne__(self, other):
10093 
    return not (self == other)
10094 
 
10095 
class addTag_result:
10096 
  """
10097 
  Attributes:
10098 
   - success
10099 
  """
10100 
 
10101 
  thrift_spec = (
10102 
    (0, TType.BOOL, 'success', None, None, ), # 0
10103 
  )
10104 
 
10105 
  def __init__(self, success=None,):
10106 
    self.success = success
10107 
 
10108 
  def read(self, iprot):
10109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10111 
      return
10112 
    iprot.readStructBegin()
10113 
    while True:
10114 
      (fname, ftype, fid) = iprot.readFieldBegin()
10115 
      if ftype == TType.STOP:
10116 
        break
10117 
      if fid == 0:
10118 
        if ftype == TType.BOOL:
10119 
          self.success = iprot.readBool();
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      else:
10123 
        iprot.skip(ftype)
10124 
      iprot.readFieldEnd()
10125 
    iprot.readStructEnd()
10126 
 
10127 
  def write(self, oprot):
10128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10130 
      return
10131 
    oprot.writeStructBegin('addTag_result')
10132 
    if self.success is not None:
10133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10134 
      oprot.writeBool(self.success)
10135 
      oprot.writeFieldEnd()
10136 
    oprot.writeFieldStop()
10137 
    oprot.writeStructEnd()
10138 
 
10139 
  def validate(self):
10140 
    return
10141 
 
10142 
 
10143 
  def __repr__(self):
10144 
    L = ['%s=%r' % (key, value)
10145 
      for key, value in self.__dict__.iteritems()]
10146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10147 
 
10148 
  def __eq__(self, other):
10149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10150 
 
10151 
  def __ne__(self, other):
10152 
    return not (self == other)
10153 
 
10154 
class deleteEntityTag_args:
10155 
  """
10156 
  Attributes:
10157 
   - displayName
10158 
   - itemId
10159 
  """
10160 
 
10161 
  thrift_spec = (
10162 
    None, # 0
10163 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10164 
    (2, TType.I64, 'itemId', None, None, ), # 2
10165 
  )
10166 
 
10167 
  def __init__(self, displayName=None, itemId=None,):
10168 
    self.displayName = displayName
10169 
    self.itemId = itemId
10170 
 
10171 
  def read(self, iprot):
10172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10174 
      return
10175 
    iprot.readStructBegin()
10176 
    while True:
10177 
      (fname, ftype, fid) = iprot.readFieldBegin()
10178 
      if ftype == TType.STOP:
10179 
        break
10180 
      if fid == 1:
10181 
        if ftype == TType.STRING:
10182 
          self.displayName = iprot.readString();
10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      elif fid == 2:
10186 
        if ftype == TType.I64:
10187 
          self.itemId = iprot.readI64();
10188 
        else:
10189 
          iprot.skip(ftype)
10190 
      else:
10191 
        iprot.skip(ftype)
10192 
      iprot.readFieldEnd()
10193 
    iprot.readStructEnd()
10194 
 
10195 
  def write(self, oprot):
10196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10198 
      return
10199 
    oprot.writeStructBegin('deleteEntityTag_args')
10200 
    if self.displayName is not None:
10201 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10202 
      oprot.writeString(self.displayName)
10203 
      oprot.writeFieldEnd()
10204 
    if self.itemId is not None:
10205 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10206 
      oprot.writeI64(self.itemId)
10207 
      oprot.writeFieldEnd()
10208 
    oprot.writeFieldStop()
10209 
    oprot.writeStructEnd()
10210 
 
10211 
  def validate(self):
10212 
    return
10213 
 
10214 
 
10215 
  def __repr__(self):
10216 
    L = ['%s=%r' % (key, value)
10217 
      for key, value in self.__dict__.iteritems()]
10218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10219 
 
10220 
  def __eq__(self, other):
10221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10222 
 
10223 
  def __ne__(self, other):
10224 
    return not (self == other)
10225 
 
10226 
class deleteEntityTag_result:
10227 
  """
10228 
  Attributes:
10229 
   - success
10230 
  """
10231 
 
10232 
  thrift_spec = (
10233 
    (0, TType.BOOL, 'success', None, None, ), # 0
10234 
  )
10235 
 
10236 
  def __init__(self, success=None,):
10237 
    self.success = success
10238 
 
10239 
  def read(self, iprot):
10240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10242 
      return
10243 
    iprot.readStructBegin()
10244 
    while True:
10245 
      (fname, ftype, fid) = iprot.readFieldBegin()
10246 
      if ftype == TType.STOP:
10247 
        break
10248 
      if fid == 0:
10249 
        if ftype == TType.BOOL:
10250 
          self.success = iprot.readBool();
10251 
        else:
10252 
          iprot.skip(ftype)
10253 
      else:
10254 
        iprot.skip(ftype)
10255 
      iprot.readFieldEnd()
10256 
    iprot.readStructEnd()
10257 
 
10258 
  def write(self, oprot):
10259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10261 
      return
10262 
    oprot.writeStructBegin('deleteEntityTag_result')
10263 
    if self.success is not None:
10264 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10265 
      oprot.writeBool(self.success)
10266 
      oprot.writeFieldEnd()
10267 
    oprot.writeFieldStop()
10268 
    oprot.writeStructEnd()
10269 
 
10270 
  def validate(self):
10271 
    return
10272 
 
10273 
 
10274 
  def __repr__(self):
10275 
    L = ['%s=%r' % (key, value)
10276 
      for key, value in self.__dict__.iteritems()]
10277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10278 
 
10279 
  def __eq__(self, other):
10280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10281 
 
10282 
  def __ne__(self, other):
10283 
    return not (self == other)
10284 
 
10285 
class deleteTag_args:
10286 
  """
10287 
  Attributes:
10288 
   - displayName
10289 
  """
10290 
 
10291 
  thrift_spec = (
10292 
    None, # 0
10293 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10294 
  )
10295 
 
10296 
  def __init__(self, displayName=None,):
10297 
    self.displayName = displayName
10298 
 
10299 
  def read(self, iprot):
10300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10302 
      return
10303 
    iprot.readStructBegin()
10304 
    while True:
10305 
      (fname, ftype, fid) = iprot.readFieldBegin()
10306 
      if ftype == TType.STOP:
10307 
        break
10308 
      if fid == 1:
10309 
        if ftype == TType.STRING:
10310 
          self.displayName = iprot.readString();
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      else:
10314 
        iprot.skip(ftype)
10315 
      iprot.readFieldEnd()
10316 
    iprot.readStructEnd()
10317 
 
10318 
  def write(self, oprot):
10319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10321 
      return
10322 
    oprot.writeStructBegin('deleteTag_args')
10323 
    if self.displayName is not None:
10324 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10325 
      oprot.writeString(self.displayName)
10326 
      oprot.writeFieldEnd()
10327 
    oprot.writeFieldStop()
10328 
    oprot.writeStructEnd()
10329 
 
10330 
  def validate(self):
10331 
    return
10332 
 
10333 
 
10334 
  def __repr__(self):
10335 
    L = ['%s=%r' % (key, value)
10336 
      for key, value in self.__dict__.iteritems()]
10337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10338 
 
10339 
  def __eq__(self, other):
10340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10341 
 
10342 
  def __ne__(self, other):
10343 
    return not (self == other)
10344 
 
10345 
class deleteTag_result:
10346 
  """
10347 
  Attributes:
10348 
   - success
10349 
  """
10350 
 
10351 
  thrift_spec = (
10352 
    (0, TType.BOOL, 'success', None, None, ), # 0
10353 
  )
10354 
 
10355 
  def __init__(self, success=None,):
10356 
    self.success = success
10357 
 
10358 
  def read(self, iprot):
10359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10361 
      return
10362 
    iprot.readStructBegin()
10363 
    while True:
10364 
      (fname, ftype, fid) = iprot.readFieldBegin()
10365 
      if ftype == TType.STOP:
10366 
        break
10367 
      if fid == 0:
10368 
        if ftype == TType.BOOL:
10369 
          self.success = iprot.readBool();
10370 
        else:
10371 
          iprot.skip(ftype)
10372 
      else:
10373 
        iprot.skip(ftype)
10374 
      iprot.readFieldEnd()
10375 
    iprot.readStructEnd()
10376 
 
10377 
  def write(self, oprot):
10378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10380 
      return
10381 
    oprot.writeStructBegin('deleteTag_result')
10382 
    if self.success is not None:
10383 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10384 
      oprot.writeBool(self.success)
10385 
      oprot.writeFieldEnd()
10386 
    oprot.writeFieldStop()
10387 
    oprot.writeStructEnd()
10388 
 
10389 
  def validate(self):
10390 
    return
10391 
 
10392 
 
10393 
  def __repr__(self):
10394 
    L = ['%s=%r' % (key, value)
10395 
      for key, value in self.__dict__.iteritems()]
10396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10397 
 
10398 
  def __eq__(self, other):
10399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10400 
 
10401 
  def __ne__(self, other):
10402 
    return not (self == other)
10403 
 
10404 
class getAllTags_args:
10405 
 
10406 
  thrift_spec = (
10407 
  )
10408 
 
10409 
  def read(self, iprot):
10410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10412 
      return
10413 
    iprot.readStructBegin()
10414 
    while True:
10415 
      (fname, ftype, fid) = iprot.readFieldBegin()
10416 
      if ftype == TType.STOP:
10417 
        break
10418 
      else:
10419 
        iprot.skip(ftype)
10420 
      iprot.readFieldEnd()
10421 
    iprot.readStructEnd()
10422 
 
10423 
  def write(self, oprot):
10424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10426 
      return
10427 
    oprot.writeStructBegin('getAllTags_args')
10428 
    oprot.writeFieldStop()
10429 
    oprot.writeStructEnd()
10430 
 
10431 
  def validate(self):
10432 
    return
10433 
 
10434 
 
10435 
  def __repr__(self):
10436 
    L = ['%s=%r' % (key, value)
10437 
      for key, value in self.__dict__.iteritems()]
10438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10439 
 
10440 
  def __eq__(self, other):
10441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10442 
 
10443 
  def __ne__(self, other):
10444 
    return not (self == other)
10445 
 
10446 
class getAllTags_result:
10447 
  """
10448 
  Attributes:
10449 
   - success
10450 
  """
10451 
 
10452 
  thrift_spec = (
10453 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10454 
  )
10455 
 
10456 
  def __init__(self, success=None,):
10457 
    self.success = success
10458 
 
10459 
  def read(self, iprot):
10460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10462 
      return
10463 
    iprot.readStructBegin()
10464 
    while True:
10465 
      (fname, ftype, fid) = iprot.readFieldBegin()
10466 
      if ftype == TType.STOP:
10467 
        break
10468 
      if fid == 0:
10469 
        if ftype == TType.LIST:
10470 
          self.success = []
7438 amit.gupta 10471 
          (_etype154, _size151) = iprot.readListBegin()
10472 
          for _i155 in xrange(_size151):
10473 
            _elem156 = iprot.readString();
10474 
            self.success.append(_elem156)
6512 kshitij.so 10475 
          iprot.readListEnd()
10476 
        else:
10477 
          iprot.skip(ftype)
10478 
      else:
10479 
        iprot.skip(ftype)
10480 
      iprot.readFieldEnd()
10481 
    iprot.readStructEnd()
10482 
 
10483 
  def write(self, oprot):
10484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10486 
      return
10487 
    oprot.writeStructBegin('getAllTags_result')
10488 
    if self.success is not None:
10489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10490 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10491 
      for iter157 in self.success:
10492 
        oprot.writeString(iter157)
6512 kshitij.so 10493 
      oprot.writeListEnd()
10494 
      oprot.writeFieldEnd()
10495 
    oprot.writeFieldStop()
10496 
    oprot.writeStructEnd()
10497 
 
10498 
  def validate(self):
10499 
    return
10500 
 
10501 
 
10502 
  def __repr__(self):
10503 
    L = ['%s=%r' % (key, value)
10504 
      for key, value in self.__dict__.iteritems()]
10505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10506 
 
10507 
  def __eq__(self, other):
10508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10509 
 
10510 
  def __ne__(self, other):
10511 
    return not (self == other)
10512 
 
10513 
class getAllEntitiesByTagName_args:
10514 
  """
10515 
  Attributes:
10516 
   - displayName
10517 
  """
10518 
 
10519 
  thrift_spec = (
10520 
    None, # 0
10521 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10522 
  )
10523 
 
10524 
  def __init__(self, displayName=None,):
10525 
    self.displayName = displayName
10526 
 
10527 
  def read(self, iprot):
10528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10530 
      return
10531 
    iprot.readStructBegin()
10532 
    while True:
10533 
      (fname, ftype, fid) = iprot.readFieldBegin()
10534 
      if ftype == TType.STOP:
10535 
        break
10536 
      if fid == 1:
10537 
        if ftype == TType.STRING:
10538 
          self.displayName = iprot.readString();
10539 
        else:
10540 
          iprot.skip(ftype)
10541 
      else:
10542 
        iprot.skip(ftype)
10543 
      iprot.readFieldEnd()
10544 
    iprot.readStructEnd()
10545 
 
10546 
  def write(self, oprot):
10547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10549 
      return
10550 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10551 
    if self.displayName is not None:
10552 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10553 
      oprot.writeString(self.displayName)
10554 
      oprot.writeFieldEnd()
10555 
    oprot.writeFieldStop()
10556 
    oprot.writeStructEnd()
10557 
 
10558 
  def validate(self):
10559 
    return
10560 
 
10561 
 
10562 
  def __repr__(self):
10563 
    L = ['%s=%r' % (key, value)
10564 
      for key, value in self.__dict__.iteritems()]
10565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10566 
 
10567 
  def __eq__(self, other):
10568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10569 
 
10570 
  def __ne__(self, other):
10571 
    return not (self == other)
10572 
 
10573 
class getAllEntitiesByTagName_result:
10574 
  """
10575 
  Attributes:
10576 
   - success
10577 
  """
10578 
 
10579 
  thrift_spec = (
10580 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10581 
  )
10582 
 
10583 
  def __init__(self, success=None,):
10584 
    self.success = success
10585 
 
10586 
  def read(self, iprot):
10587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10589 
      return
10590 
    iprot.readStructBegin()
10591 
    while True:
10592 
      (fname, ftype, fid) = iprot.readFieldBegin()
10593 
      if ftype == TType.STOP:
10594 
        break
10595 
      if fid == 0:
10596 
        if ftype == TType.LIST:
10597 
          self.success = []
7438 amit.gupta 10598 
          (_etype161, _size158) = iprot.readListBegin()
10599 
          for _i162 in xrange(_size158):
10600 
            _elem163 = iprot.readI64();
10601 
            self.success.append(_elem163)
6512 kshitij.so 10602 
          iprot.readListEnd()
10603 
        else:
10604 
          iprot.skip(ftype)
10605 
      else:
10606 
        iprot.skip(ftype)
10607 
      iprot.readFieldEnd()
10608 
    iprot.readStructEnd()
10609 
 
10610 
  def write(self, oprot):
10611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10613 
      return
10614 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10615 
    if self.success is not None:
10616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10617 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10618 
      for iter164 in self.success:
10619 
        oprot.writeI64(iter164)
6512 kshitij.so 10620 
      oprot.writeListEnd()
10621 
      oprot.writeFieldEnd()
10622 
    oprot.writeFieldStop()
10623 
    oprot.writeStructEnd()
10624 
 
10625 
  def validate(self):
10626 
    return
10627 
 
10628 
 
10629 
  def __repr__(self):
10630 
    L = ['%s=%r' % (key, value)
10631 
      for key, value in self.__dict__.iteritems()]
10632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10633 
 
10634 
  def __eq__(self, other):
10635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10636 
 
10637 
  def __ne__(self, other):
10638 
    return not (self == other)
10639 
 
6845 amit.gupta 10640 
class getAllEntityTags_args:
10641 
 
10642 
  thrift_spec = (
10643 
  )
10644 
 
10645 
  def read(self, iprot):
10646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10648 
      return
10649 
    iprot.readStructBegin()
10650 
    while True:
10651 
      (fname, ftype, fid) = iprot.readFieldBegin()
10652 
      if ftype == TType.STOP:
10653 
        break
10654 
      else:
10655 
        iprot.skip(ftype)
10656 
      iprot.readFieldEnd()
10657 
    iprot.readStructEnd()
10658 
 
10659 
  def write(self, oprot):
10660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10662 
      return
10663 
    oprot.writeStructBegin('getAllEntityTags_args')
10664 
    oprot.writeFieldStop()
10665 
    oprot.writeStructEnd()
10666 
 
10667 
  def validate(self):
10668 
    return
10669 
 
10670 
 
10671 
  def __repr__(self):
10672 
    L = ['%s=%r' % (key, value)
10673 
      for key, value in self.__dict__.iteritems()]
10674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10675 
 
10676 
  def __eq__(self, other):
10677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10678 
 
10679 
  def __ne__(self, other):
10680 
    return not (self == other)
10681 
 
10682 
class getAllEntityTags_result:
10683 
  """
10684 
  Attributes:
10685 
   - success
10686 
  """
10687 
 
10688 
  thrift_spec = (
10689 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10690 
  )
10691 
 
10692 
  def __init__(self, success=None,):
10693 
    self.success = success
10694 
 
10695 
  def read(self, iprot):
10696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10698 
      return
10699 
    iprot.readStructBegin()
10700 
    while True:
10701 
      (fname, ftype, fid) = iprot.readFieldBegin()
10702 
      if ftype == TType.STOP:
10703 
        break
10704 
      if fid == 0:
10705 
        if ftype == TType.MAP:
10706 
          self.success = {}
7438 amit.gupta 10707 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10708 
          for _i169 in xrange(_size165):
10709 
            _key170 = iprot.readI64();
10710 
            _val171 = []
10711 
            (_etype175, _size172) = iprot.readListBegin()
10712 
            for _i176 in xrange(_size172):
10713 
              _elem177 = iprot.readString();
10714 
              _val171.append(_elem177)
6845 amit.gupta 10715 
            iprot.readListEnd()
7438 amit.gupta 10716 
            self.success[_key170] = _val171
6845 amit.gupta 10717 
          iprot.readMapEnd()
10718 
        else:
10719 
          iprot.skip(ftype)
10720 
      else:
10721 
        iprot.skip(ftype)
10722 
      iprot.readFieldEnd()
10723 
    iprot.readStructEnd()
10724 
 
10725 
  def write(self, oprot):
10726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10728 
      return
10729 
    oprot.writeStructBegin('getAllEntityTags_result')
10730 
    if self.success is not None:
10731 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10732 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10733 
      for kiter178,viter179 in self.success.items():
10734 
        oprot.writeI64(kiter178)
10735 
        oprot.writeListBegin(TType.STRING, len(viter179))
10736 
        for iter180 in viter179:
10737 
          oprot.writeString(iter180)
6845 amit.gupta 10738 
        oprot.writeListEnd()
10739 
      oprot.writeMapEnd()
10740 
      oprot.writeFieldEnd()
10741 
    oprot.writeFieldStop()
10742 
    oprot.writeStructEnd()
10743 
 
10744 
  def validate(self):
10745 
    return
10746 
 
10747 
 
10748 
  def __repr__(self):
10749 
    L = ['%s=%r' % (key, value)
10750 
      for key, value in self.__dict__.iteritems()]
10751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10752 
 
10753 
  def __eq__(self, other):
10754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10755 
 
10756 
  def __ne__(self, other):
10757 
    return not (self == other)
10758 
 
6850 kshitij.so 10759 
class addBanner_args:
10760 
  """
10761 
  Attributes:
10762 
   - bannerName
10763 
   - imageName
10764 
   - link
10765 
   - priority
10766 
   - isActive
10767 
   - hasMap
10768 
  """
10769 
 
10770 
  thrift_spec = (
10771 
    None, # 0
10772 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10773 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10774 
    (3, TType.STRING, 'link', None, None, ), # 3
10775 
    (4, TType.I64, 'priority', None, None, ), # 4
10776 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10777 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10778 
  )
10779 
 
10780 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10781 
    self.bannerName = bannerName
10782 
    self.imageName = imageName
10783 
    self.link = link
10784 
    self.priority = priority
10785 
    self.isActive = isActive
10786 
    self.hasMap = hasMap
10787 
 
10788 
  def read(self, iprot):
10789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10791 
      return
10792 
    iprot.readStructBegin()
10793 
    while True:
10794 
      (fname, ftype, fid) = iprot.readFieldBegin()
10795 
      if ftype == TType.STOP:
10796 
        break
10797 
      if fid == 1:
10798 
        if ftype == TType.STRING:
10799 
          self.bannerName = iprot.readString();
10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      elif fid == 2:
10803 
        if ftype == TType.STRING:
10804 
          self.imageName = iprot.readString();
10805 
        else:
10806 
          iprot.skip(ftype)
10807 
      elif fid == 3:
10808 
        if ftype == TType.STRING:
10809 
          self.link = iprot.readString();
10810 
        else:
10811 
          iprot.skip(ftype)
10812 
      elif fid == 4:
10813 
        if ftype == TType.I64:
10814 
          self.priority = iprot.readI64();
10815 
        else:
10816 
          iprot.skip(ftype)
10817 
      elif fid == 5:
10818 
        if ftype == TType.BOOL:
10819 
          self.isActive = iprot.readBool();
10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      elif fid == 6:
10823 
        if ftype == TType.BOOL:
10824 
          self.hasMap = iprot.readBool();
10825 
        else:
10826 
          iprot.skip(ftype)
10827 
      else:
10828 
        iprot.skip(ftype)
10829 
      iprot.readFieldEnd()
10830 
    iprot.readStructEnd()
10831 
 
10832 
  def write(self, oprot):
10833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10835 
      return
10836 
    oprot.writeStructBegin('addBanner_args')
10837 
    if self.bannerName is not None:
10838 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10839 
      oprot.writeString(self.bannerName)
10840 
      oprot.writeFieldEnd()
10841 
    if self.imageName is not None:
10842 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10843 
      oprot.writeString(self.imageName)
10844 
      oprot.writeFieldEnd()
10845 
    if self.link is not None:
10846 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10847 
      oprot.writeString(self.link)
10848 
      oprot.writeFieldEnd()
10849 
    if self.priority is not None:
10850 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10851 
      oprot.writeI64(self.priority)
10852 
      oprot.writeFieldEnd()
10853 
    if self.isActive is not None:
10854 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10855 
      oprot.writeBool(self.isActive)
10856 
      oprot.writeFieldEnd()
10857 
    if self.hasMap is not None:
10858 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10859 
      oprot.writeBool(self.hasMap)
10860 
      oprot.writeFieldEnd()
10861 
    oprot.writeFieldStop()
10862 
    oprot.writeStructEnd()
10863 
 
10864 
  def validate(self):
10865 
    return
10866 
 
10867 
 
10868 
  def __repr__(self):
10869 
    L = ['%s=%r' % (key, value)
10870 
      for key, value in self.__dict__.iteritems()]
10871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10872 
 
10873 
  def __eq__(self, other):
10874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10875 
 
10876 
  def __ne__(self, other):
10877 
    return not (self == other)
10878 
 
10879 
class addBanner_result:
10880 
  """
10881 
  Attributes:
10882 
   - success
10883 
  """
10884 
 
10885 
  thrift_spec = (
10886 
    (0, TType.BOOL, 'success', None, None, ), # 0
10887 
  )
10888 
 
10889 
  def __init__(self, success=None,):
10890 
    self.success = success
10891 
 
10892 
  def read(self, iprot):
10893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10895 
      return
10896 
    iprot.readStructBegin()
10897 
    while True:
10898 
      (fname, ftype, fid) = iprot.readFieldBegin()
10899 
      if ftype == TType.STOP:
10900 
        break
10901 
      if fid == 0:
10902 
        if ftype == TType.BOOL:
10903 
          self.success = iprot.readBool();
10904 
        else:
10905 
          iprot.skip(ftype)
10906 
      else:
10907 
        iprot.skip(ftype)
10908 
      iprot.readFieldEnd()
10909 
    iprot.readStructEnd()
10910 
 
10911 
  def write(self, oprot):
10912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10914 
      return
10915 
    oprot.writeStructBegin('addBanner_result')
10916 
    if self.success is not None:
10917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10918 
      oprot.writeBool(self.success)
10919 
      oprot.writeFieldEnd()
10920 
    oprot.writeFieldStop()
10921 
    oprot.writeStructEnd()
10922 
 
10923 
  def validate(self):
10924 
    return
10925 
 
10926 
 
10927 
  def __repr__(self):
10928 
    L = ['%s=%r' % (key, value)
10929 
      for key, value in self.__dict__.iteritems()]
10930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10931 
 
10932 
  def __eq__(self, other):
10933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10934 
 
10935 
  def __ne__(self, other):
10936 
    return not (self == other)
10937 
 
10938 
class getAllBanners_args:
10939 
 
10940 
  thrift_spec = (
10941 
  )
10942 
 
10943 
  def read(self, iprot):
10944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10946 
      return
10947 
    iprot.readStructBegin()
10948 
    while True:
10949 
      (fname, ftype, fid) = iprot.readFieldBegin()
10950 
      if ftype == TType.STOP:
10951 
        break
10952 
      else:
10953 
        iprot.skip(ftype)
10954 
      iprot.readFieldEnd()
10955 
    iprot.readStructEnd()
10956 
 
10957 
  def write(self, oprot):
10958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10960 
      return
10961 
    oprot.writeStructBegin('getAllBanners_args')
10962 
    oprot.writeFieldStop()
10963 
    oprot.writeStructEnd()
10964 
 
10965 
  def validate(self):
10966 
    return
10967 
 
10968 
 
10969 
  def __repr__(self):
10970 
    L = ['%s=%r' % (key, value)
10971 
      for key, value in self.__dict__.iteritems()]
10972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10973 
 
10974 
  def __eq__(self, other):
10975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10976 
 
10977 
  def __ne__(self, other):
10978 
    return not (self == other)
10979 
 
10980 
class getAllBanners_result:
10981 
  """
10982 
  Attributes:
10983 
   - success
10984 
  """
10985 
 
10986 
  thrift_spec = (
10987 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10988 
  )
10989 
 
10990 
  def __init__(self, success=None,):
10991 
    self.success = success
10992 
 
10993 
  def read(self, iprot):
10994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10996 
      return
10997 
    iprot.readStructBegin()
10998 
    while True:
10999 
      (fname, ftype, fid) = iprot.readFieldBegin()
11000 
      if ftype == TType.STOP:
11001 
        break
11002 
      if fid == 0:
11003 
        if ftype == TType.LIST:
11004 
          self.success = []
7438 amit.gupta 11005 
          (_etype184, _size181) = iprot.readListBegin()
11006 
          for _i185 in xrange(_size181):
11007 
            _elem186 = iprot.readString();
11008 
            self.success.append(_elem186)
6850 kshitij.so 11009 
          iprot.readListEnd()
11010 
        else:
11011 
          iprot.skip(ftype)
11012 
      else:
11013 
        iprot.skip(ftype)
11014 
      iprot.readFieldEnd()
11015 
    iprot.readStructEnd()
11016 
 
11017 
  def write(self, oprot):
11018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11020 
      return
11021 
    oprot.writeStructBegin('getAllBanners_result')
11022 
    if self.success is not None:
11023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11024 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11025 
      for iter187 in self.success:
11026 
        oprot.writeString(iter187)
6850 kshitij.so 11027 
      oprot.writeListEnd()
11028 
      oprot.writeFieldEnd()
11029 
    oprot.writeFieldStop()
11030 
    oprot.writeStructEnd()
11031 
 
11032 
  def validate(self):
11033 
    return
11034 
 
11035 
 
11036 
  def __repr__(self):
11037 
    L = ['%s=%r' % (key, value)
11038 
      for key, value in self.__dict__.iteritems()]
11039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11040 
 
11041 
  def __eq__(self, other):
11042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11043 
 
11044 
  def __ne__(self, other):
11045 
    return not (self == other)
11046 
 
11047 
class deleteBanner_args:
11048 
  """
11049 
  Attributes:
11050 
   - bannerName
11051 
  """
11052 
 
11053 
  thrift_spec = (
11054 
    None, # 0
11055 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11056 
  )
11057 
 
11058 
  def __init__(self, bannerName=None,):
11059 
    self.bannerName = bannerName
11060 
 
11061 
  def read(self, iprot):
11062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11064 
      return
11065 
    iprot.readStructBegin()
11066 
    while True:
11067 
      (fname, ftype, fid) = iprot.readFieldBegin()
11068 
      if ftype == TType.STOP:
11069 
        break
11070 
      if fid == 1:
11071 
        if ftype == TType.STRING:
11072 
          self.bannerName = iprot.readString();
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      else:
11076 
        iprot.skip(ftype)
11077 
      iprot.readFieldEnd()
11078 
    iprot.readStructEnd()
11079 
 
11080 
  def write(self, oprot):
11081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11083 
      return
11084 
    oprot.writeStructBegin('deleteBanner_args')
11085 
    if self.bannerName is not None:
11086 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11087 
      oprot.writeString(self.bannerName)
11088 
      oprot.writeFieldEnd()
11089 
    oprot.writeFieldStop()
11090 
    oprot.writeStructEnd()
11091 
 
11092 
  def validate(self):
11093 
    return
11094 
 
11095 
 
11096 
  def __repr__(self):
11097 
    L = ['%s=%r' % (key, value)
11098 
      for key, value in self.__dict__.iteritems()]
11099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11100 
 
11101 
  def __eq__(self, other):
11102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11103 
 
11104 
  def __ne__(self, other):
11105 
    return not (self == other)
11106 
 
11107 
class deleteBanner_result:
11108 
  """
11109 
  Attributes:
11110 
   - success
11111 
  """
11112 
 
11113 
  thrift_spec = (
11114 
    (0, TType.BOOL, 'success', None, None, ), # 0
11115 
  )
11116 
 
11117 
  def __init__(self, success=None,):
11118 
    self.success = success
11119 
 
11120 
  def read(self, iprot):
11121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11123 
      return
11124 
    iprot.readStructBegin()
11125 
    while True:
11126 
      (fname, ftype, fid) = iprot.readFieldBegin()
11127 
      if ftype == TType.STOP:
11128 
        break
11129 
      if fid == 0:
11130 
        if ftype == TType.BOOL:
11131 
          self.success = iprot.readBool();
11132 
        else:
11133 
          iprot.skip(ftype)
11134 
      else:
11135 
        iprot.skip(ftype)
11136 
      iprot.readFieldEnd()
11137 
    iprot.readStructEnd()
11138 
 
11139 
  def write(self, oprot):
11140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11142 
      return
11143 
    oprot.writeStructBegin('deleteBanner_result')
11144 
    if self.success is not None:
11145 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11146 
      oprot.writeBool(self.success)
11147 
      oprot.writeFieldEnd()
11148 
    oprot.writeFieldStop()
11149 
    oprot.writeStructEnd()
11150 
 
11151 
  def validate(self):
11152 
    return
11153 
 
11154 
 
11155 
  def __repr__(self):
11156 
    L = ['%s=%r' % (key, value)
11157 
      for key, value in self.__dict__.iteritems()]
11158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11159 
 
11160 
  def __eq__(self, other):
11161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11162 
 
11163 
  def __ne__(self, other):
11164 
    return not (self == other)
11165 
 
11166 
class getBannerDetails_args:
11167 
  """
11168 
  Attributes:
11169 
   - bannerName
11170 
  """
11171 
 
11172 
  thrift_spec = (
11173 
    None, # 0
11174 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11175 
  )
11176 
 
11177 
  def __init__(self, bannerName=None,):
11178 
    self.bannerName = bannerName
11179 
 
11180 
  def read(self, iprot):
11181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11183 
      return
11184 
    iprot.readStructBegin()
11185 
    while True:
11186 
      (fname, ftype, fid) = iprot.readFieldBegin()
11187 
      if ftype == TType.STOP:
11188 
        break
11189 
      if fid == 1:
11190 
        if ftype == TType.STRING:
11191 
          self.bannerName = iprot.readString();
11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      else:
11195 
        iprot.skip(ftype)
11196 
      iprot.readFieldEnd()
11197 
    iprot.readStructEnd()
11198 
 
11199 
  def write(self, oprot):
11200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11202 
      return
11203 
    oprot.writeStructBegin('getBannerDetails_args')
11204 
    if self.bannerName is not None:
11205 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11206 
      oprot.writeString(self.bannerName)
11207 
      oprot.writeFieldEnd()
11208 
    oprot.writeFieldStop()
11209 
    oprot.writeStructEnd()
11210 
 
11211 
  def validate(self):
11212 
    return
11213 
 
11214 
 
11215 
  def __repr__(self):
11216 
    L = ['%s=%r' % (key, value)
11217 
      for key, value in self.__dict__.iteritems()]
11218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11219 
 
11220 
  def __eq__(self, other):
11221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11222 
 
11223 
  def __ne__(self, other):
11224 
    return not (self == other)
11225 
 
11226 
class getBannerDetails_result:
11227 
  """
11228 
  Attributes:
11229 
   - success
11230 
  """
11231 
 
11232 
  thrift_spec = (
11233 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11234 
  )
11235 
 
11236 
  def __init__(self, success=None,):
11237 
    self.success = success
11238 
 
11239 
  def read(self, iprot):
11240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11242 
      return
11243 
    iprot.readStructBegin()
11244 
    while True:
11245 
      (fname, ftype, fid) = iprot.readFieldBegin()
11246 
      if ftype == TType.STOP:
11247 
        break
11248 
      if fid == 0:
11249 
        if ftype == TType.STRUCT:
11250 
          self.success = Banner()
11251 
          self.success.read(iprot)
11252 
        else:
11253 
          iprot.skip(ftype)
11254 
      else:
11255 
        iprot.skip(ftype)
11256 
      iprot.readFieldEnd()
11257 
    iprot.readStructEnd()
11258 
 
11259 
  def write(self, oprot):
11260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11262 
      return
11263 
    oprot.writeStructBegin('getBannerDetails_result')
11264 
    if self.success is not None:
11265 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11266 
      self.success.write(oprot)
11267 
      oprot.writeFieldEnd()
11268 
    oprot.writeFieldStop()
11269 
    oprot.writeStructEnd()
11270 
 
11271 
  def validate(self):
11272 
    return
11273 
 
11274 
 
11275 
  def __repr__(self):
11276 
    L = ['%s=%r' % (key, value)
11277 
      for key, value in self.__dict__.iteritems()]
11278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11279 
 
11280 
  def __eq__(self, other):
11281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11282 
 
11283 
  def __ne__(self, other):
11284 
    return not (self == other)
11285 
 
11286 
class getActiveBanners_args:
11287 
 
11288 
  thrift_spec = (
11289 
  )
11290 
 
11291 
  def read(self, iprot):
11292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11294 
      return
11295 
    iprot.readStructBegin()
11296 
    while True:
11297 
      (fname, ftype, fid) = iprot.readFieldBegin()
11298 
      if ftype == TType.STOP:
11299 
        break
11300 
      else:
11301 
        iprot.skip(ftype)
11302 
      iprot.readFieldEnd()
11303 
    iprot.readStructEnd()
11304 
 
11305 
  def write(self, oprot):
11306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11308 
      return
11309 
    oprot.writeStructBegin('getActiveBanners_args')
11310 
    oprot.writeFieldStop()
11311 
    oprot.writeStructEnd()
11312 
 
11313 
  def validate(self):
11314 
    return
11315 
 
11316 
 
11317 
  def __repr__(self):
11318 
    L = ['%s=%r' % (key, value)
11319 
      for key, value in self.__dict__.iteritems()]
11320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11321 
 
11322 
  def __eq__(self, other):
11323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11324 
 
11325 
  def __ne__(self, other):
11326 
    return not (self == other)
11327 
 
11328 
class getActiveBanners_result:
11329 
  """
11330 
  Attributes:
11331 
   - success
11332 
  """
11333 
 
11334 
  thrift_spec = (
11335 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11336 
  )
11337 
 
11338 
  def __init__(self, success=None,):
11339 
    self.success = success
11340 
 
11341 
  def read(self, iprot):
11342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11344 
      return
11345 
    iprot.readStructBegin()
11346 
    while True:
11347 
      (fname, ftype, fid) = iprot.readFieldBegin()
11348 
      if ftype == TType.STOP:
11349 
        break
11350 
      if fid == 0:
11351 
        if ftype == TType.LIST:
11352 
          self.success = []
7438 amit.gupta 11353 
          (_etype191, _size188) = iprot.readListBegin()
11354 
          for _i192 in xrange(_size188):
11355 
            _elem193 = Banner()
11356 
            _elem193.read(iprot)
11357 
            self.success.append(_elem193)
6850 kshitij.so 11358 
          iprot.readListEnd()
11359 
        else:
11360 
          iprot.skip(ftype)
11361 
      else:
11362 
        iprot.skip(ftype)
11363 
      iprot.readFieldEnd()
11364 
    iprot.readStructEnd()
11365 
 
11366 
  def write(self, oprot):
11367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11369 
      return
11370 
    oprot.writeStructBegin('getActiveBanners_result')
11371 
    if self.success is not None:
11372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11374 
      for iter194 in self.success:
11375 
        iter194.write(oprot)
6850 kshitij.so 11376 
      oprot.writeListEnd()
11377 
      oprot.writeFieldEnd()
11378 
    oprot.writeFieldStop()
11379 
    oprot.writeStructEnd()
11380 
 
11381 
  def validate(self):
11382 
    return
11383 
 
11384 
 
11385 
  def __repr__(self):
11386 
    L = ['%s=%r' % (key, value)
11387 
      for key, value in self.__dict__.iteritems()]
11388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11389 
 
11390 
  def __eq__(self, other):
11391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11392 
 
11393 
  def __ne__(self, other):
11394 
    return not (self == other)
11395 
 
6849 kshitij.so 11396 
class addBannerMap_args:
11397 
  """
11398 
  Attributes:
11399 
   - bannerName
11400 
   - mapLink
11401 
   - coordinates
11402 
  """
11403 
 
11404 
  thrift_spec = (
11405 
    None, # 0
11406 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11407 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11408 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11409 
  )
11410 
 
11411 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11412 
    self.bannerName = bannerName
11413 
    self.mapLink = mapLink
11414 
    self.coordinates = coordinates
11415 
 
11416 
  def read(self, iprot):
11417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11419 
      return
11420 
    iprot.readStructBegin()
11421 
    while True:
11422 
      (fname, ftype, fid) = iprot.readFieldBegin()
11423 
      if ftype == TType.STOP:
11424 
        break
11425 
      if fid == 1:
11426 
        if ftype == TType.STRING:
11427 
          self.bannerName = iprot.readString();
11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      elif fid == 2:
11431 
        if ftype == TType.STRING:
11432 
          self.mapLink = iprot.readString();
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      elif fid == 3:
11436 
        if ftype == TType.STRING:
11437 
          self.coordinates = iprot.readString();
11438 
        else:
11439 
          iprot.skip(ftype)
11440 
      else:
11441 
        iprot.skip(ftype)
11442 
      iprot.readFieldEnd()
11443 
    iprot.readStructEnd()
11444 
 
11445 
  def write(self, oprot):
11446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11448 
      return
11449 
    oprot.writeStructBegin('addBannerMap_args')
11450 
    if self.bannerName is not None:
11451 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11452 
      oprot.writeString(self.bannerName)
11453 
      oprot.writeFieldEnd()
11454 
    if self.mapLink is not None:
11455 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11456 
      oprot.writeString(self.mapLink)
11457 
      oprot.writeFieldEnd()
11458 
    if self.coordinates is not None:
11459 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11460 
      oprot.writeString(self.coordinates)
11461 
      oprot.writeFieldEnd()
11462 
    oprot.writeFieldStop()
11463 
    oprot.writeStructEnd()
11464 
 
11465 
  def validate(self):
11466 
    return
11467 
 
11468 
 
11469 
  def __repr__(self):
11470 
    L = ['%s=%r' % (key, value)
11471 
      for key, value in self.__dict__.iteritems()]
11472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11473 
 
11474 
  def __eq__(self, other):
11475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11476 
 
11477 
  def __ne__(self, other):
11478 
    return not (self == other)
11479 
 
11480 
class addBannerMap_result:
11481 
  """
11482 
  Attributes:
11483 
   - success
11484 
  """
11485 
 
11486 
  thrift_spec = (
11487 
    (0, TType.BOOL, 'success', None, None, ), # 0
11488 
  )
11489 
 
11490 
  def __init__(self, success=None,):
11491 
    self.success = success
11492 
 
11493 
  def read(self, iprot):
11494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11496 
      return
11497 
    iprot.readStructBegin()
11498 
    while True:
11499 
      (fname, ftype, fid) = iprot.readFieldBegin()
11500 
      if ftype == TType.STOP:
11501 
        break
11502 
      if fid == 0:
11503 
        if ftype == TType.BOOL:
11504 
          self.success = iprot.readBool();
11505 
        else:
11506 
          iprot.skip(ftype)
11507 
      else:
11508 
        iprot.skip(ftype)
11509 
      iprot.readFieldEnd()
11510 
    iprot.readStructEnd()
11511 
 
11512 
  def write(self, oprot):
11513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11515 
      return
11516 
    oprot.writeStructBegin('addBannerMap_result')
11517 
    if self.success is not None:
11518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11519 
      oprot.writeBool(self.success)
11520 
      oprot.writeFieldEnd()
11521 
    oprot.writeFieldStop()
11522 
    oprot.writeStructEnd()
11523 
 
11524 
  def validate(self):
11525 
    return
11526 
 
11527 
 
11528 
  def __repr__(self):
11529 
    L = ['%s=%r' % (key, value)
11530 
      for key, value in self.__dict__.iteritems()]
11531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11532 
 
11533 
  def __eq__(self, other):
11534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11535 
 
11536 
  def __ne__(self, other):
11537 
    return not (self == other)
11538 
 
11539 
class deleteBannerMap_args:
11540 
  """
11541 
  Attributes:
11542 
   - bannerName
11543 
  """
11544 
 
11545 
  thrift_spec = (
11546 
    None, # 0
11547 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11548 
  )
11549 
 
11550 
  def __init__(self, bannerName=None,):
11551 
    self.bannerName = bannerName
11552 
 
11553 
  def read(self, iprot):
11554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11556 
      return
11557 
    iprot.readStructBegin()
11558 
    while True:
11559 
      (fname, ftype, fid) = iprot.readFieldBegin()
11560 
      if ftype == TType.STOP:
11561 
        break
11562 
      if fid == 1:
11563 
        if ftype == TType.STRING:
11564 
          self.bannerName = iprot.readString();
11565 
        else:
11566 
          iprot.skip(ftype)
11567 
      else:
11568 
        iprot.skip(ftype)
11569 
      iprot.readFieldEnd()
11570 
    iprot.readStructEnd()
11571 
 
11572 
  def write(self, oprot):
11573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11575 
      return
11576 
    oprot.writeStructBegin('deleteBannerMap_args')
11577 
    if self.bannerName is not None:
11578 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11579 
      oprot.writeString(self.bannerName)
11580 
      oprot.writeFieldEnd()
11581 
    oprot.writeFieldStop()
11582 
    oprot.writeStructEnd()
11583 
 
11584 
  def validate(self):
11585 
    return
11586 
 
11587 
 
11588 
  def __repr__(self):
11589 
    L = ['%s=%r' % (key, value)
11590 
      for key, value in self.__dict__.iteritems()]
11591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11592 
 
11593 
  def __eq__(self, other):
11594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11595 
 
11596 
  def __ne__(self, other):
11597 
    return not (self == other)
11598 
 
11599 
class deleteBannerMap_result:
11600 
  """
11601 
  Attributes:
11602 
   - success
11603 
  """
11604 
 
11605 
  thrift_spec = (
11606 
    (0, TType.BOOL, 'success', None, None, ), # 0
11607 
  )
11608 
 
11609 
  def __init__(self, success=None,):
11610 
    self.success = success
11611 
 
11612 
  def read(self, iprot):
11613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11615 
      return
11616 
    iprot.readStructBegin()
11617 
    while True:
11618 
      (fname, ftype, fid) = iprot.readFieldBegin()
11619 
      if ftype == TType.STOP:
11620 
        break
11621 
      if fid == 0:
11622 
        if ftype == TType.BOOL:
11623 
          self.success = iprot.readBool();
11624 
        else:
11625 
          iprot.skip(ftype)
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('deleteBannerMap_result')
11636 
    if self.success is not None:
11637 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11638 
      oprot.writeBool(self.success)
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 getBannerMapDetails_args:
11659 
  """
11660 
  Attributes:
11661 
   - bannerName
11662 
  """
11663 
 
11664 
  thrift_spec = (
11665 
    None, # 0
11666 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11667 
  )
11668 
 
11669 
  def __init__(self, bannerName=None,):
11670 
    self.bannerName = bannerName
11671 
 
11672 
  def read(self, iprot):
11673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11675 
      return
11676 
    iprot.readStructBegin()
11677 
    while True:
11678 
      (fname, ftype, fid) = iprot.readFieldBegin()
11679 
      if ftype == TType.STOP:
11680 
        break
11681 
      if fid == 1:
11682 
        if ftype == TType.STRING:
11683 
          self.bannerName = iprot.readString();
11684 
        else:
11685 
          iprot.skip(ftype)
11686 
      else:
11687 
        iprot.skip(ftype)
11688 
      iprot.readFieldEnd()
11689 
    iprot.readStructEnd()
11690 
 
11691 
  def write(self, oprot):
11692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11694 
      return
11695 
    oprot.writeStructBegin('getBannerMapDetails_args')
11696 
    if self.bannerName is not None:
11697 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11698 
      oprot.writeString(self.bannerName)
11699 
      oprot.writeFieldEnd()
11700 
    oprot.writeFieldStop()
11701 
    oprot.writeStructEnd()
11702 
 
11703 
  def validate(self):
11704 
    return
11705 
 
11706 
 
11707 
  def __repr__(self):
11708 
    L = ['%s=%r' % (key, value)
11709 
      for key, value in self.__dict__.iteritems()]
11710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11711 
 
11712 
  def __eq__(self, other):
11713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11714 
 
11715 
  def __ne__(self, other):
11716 
    return not (self == other)
11717 
 
11718 
class getBannerMapDetails_result:
11719 
  """
11720 
  Attributes:
11721 
   - success
11722 
  """
11723 
 
11724 
  thrift_spec = (
11725 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11726 
  )
11727 
 
11728 
  def __init__(self, success=None,):
11729 
    self.success = success
11730 
 
11731 
  def read(self, iprot):
11732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11734 
      return
11735 
    iprot.readStructBegin()
11736 
    while True:
11737 
      (fname, ftype, fid) = iprot.readFieldBegin()
11738 
      if ftype == TType.STOP:
11739 
        break
11740 
      if fid == 0:
11741 
        if ftype == TType.LIST:
11742 
          self.success = []
7438 amit.gupta 11743 
          (_etype198, _size195) = iprot.readListBegin()
11744 
          for _i199 in xrange(_size195):
11745 
            _elem200 = BannerMap()
11746 
            _elem200.read(iprot)
11747 
            self.success.append(_elem200)
6849 kshitij.so 11748 
          iprot.readListEnd()
11749 
        else:
11750 
          iprot.skip(ftype)
11751 
      else:
11752 
        iprot.skip(ftype)
11753 
      iprot.readFieldEnd()
11754 
    iprot.readStructEnd()
11755 
 
11756 
  def write(self, oprot):
11757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11759 
      return
11760 
    oprot.writeStructBegin('getBannerMapDetails_result')
11761 
    if self.success is not None:
11762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11764 
      for iter201 in self.success:
11765 
        iter201.write(oprot)
6849 kshitij.so 11766 
      oprot.writeListEnd()
11767 
      oprot.writeFieldEnd()
11768 
    oprot.writeFieldStop()
11769 
    oprot.writeStructEnd()
11770 
 
11771 
  def validate(self):
11772 
    return
11773 
 
11774 
 
11775 
  def __repr__(self):
11776 
    L = ['%s=%r' % (key, value)
11777 
      for key, value in self.__dict__.iteritems()]
11778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11779 
 
11780 
  def __eq__(self, other):
11781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11782 
 
11783 
  def __ne__(self, other):
11784 
    return not (self == other)
11785 
 
5944 mandeep.dh 11786 
class deleteSimilarItem_args:
11787 
  """
11788 
  Attributes:
11789 
   - itemId
11790 
   - catalogItemId
11791 
  """
11792 
 
11793 
  thrift_spec = (
11794 
    None, # 0
11795 
    (1, TType.I64, 'itemId', None, None, ), # 1
11796 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11797 
  )
11798 
 
11799 
  def __init__(self, itemId=None, catalogItemId=None,):
11800 
    self.itemId = itemId
11801 
    self.catalogItemId = catalogItemId
11802 
 
11803 
  def read(self, iprot):
11804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11806 
      return
11807 
    iprot.readStructBegin()
11808 
    while True:
11809 
      (fname, ftype, fid) = iprot.readFieldBegin()
11810 
      if ftype == TType.STOP:
11811 
        break
11812 
      if fid == 1:
11813 
        if ftype == TType.I64:
11814 
          self.itemId = iprot.readI64();
11815 
        else:
11816 
          iprot.skip(ftype)
11817 
      elif fid == 2:
11818 
        if ftype == TType.I64:
11819 
          self.catalogItemId = iprot.readI64();
11820 
        else:
11821 
          iprot.skip(ftype)
11822 
      else:
11823 
        iprot.skip(ftype)
11824 
      iprot.readFieldEnd()
11825 
    iprot.readStructEnd()
11826 
 
11827 
  def write(self, oprot):
11828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11830 
      return
11831 
    oprot.writeStructBegin('deleteSimilarItem_args')
11832 
    if self.itemId is not None:
11833 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11834 
      oprot.writeI64(self.itemId)
11835 
      oprot.writeFieldEnd()
11836 
    if self.catalogItemId is not None:
11837 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11838 
      oprot.writeI64(self.catalogItemId)
11839 
      oprot.writeFieldEnd()
11840 
    oprot.writeFieldStop()
11841 
    oprot.writeStructEnd()
11842 
 
11843 
  def validate(self):
11844 
    return
11845 
 
11846 
 
11847 
  def __repr__(self):
11848 
    L = ['%s=%r' % (key, value)
11849 
      for key, value in self.__dict__.iteritems()]
11850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11851 
 
11852 
  def __eq__(self, other):
11853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11854 
 
11855 
  def __ne__(self, other):
11856 
    return not (self == other)
11857 
 
11858 
class deleteSimilarItem_result:
11859 
  """
11860 
  Attributes:
11861 
   - success
11862 
   - cex
11863 
  """
11864 
 
11865 
  thrift_spec = (
11866 
    (0, TType.BOOL, 'success', None, None, ), # 0
11867 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11868 
  )
11869 
 
11870 
  def __init__(self, success=None, cex=None,):
11871 
    self.success = success
11872 
    self.cex = cex
11873 
 
11874 
  def read(self, iprot):
11875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11877 
      return
11878 
    iprot.readStructBegin()
11879 
    while True:
11880 
      (fname, ftype, fid) = iprot.readFieldBegin()
11881 
      if ftype == TType.STOP:
11882 
        break
11883 
      if fid == 0:
11884 
        if ftype == TType.BOOL:
11885 
          self.success = iprot.readBool();
11886 
        else:
11887 
          iprot.skip(ftype)
11888 
      elif fid == 1:
11889 
        if ftype == TType.STRUCT:
11890 
          self.cex = CatalogServiceException()
11891 
          self.cex.read(iprot)
11892 
        else:
11893 
          iprot.skip(ftype)
11894 
      else:
11895 
        iprot.skip(ftype)
11896 
      iprot.readFieldEnd()
11897 
    iprot.readStructEnd()
11898 
 
11899 
  def write(self, oprot):
11900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11902 
      return
11903 
    oprot.writeStructBegin('deleteSimilarItem_result')
11904 
    if self.success is not None:
11905 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11906 
      oprot.writeBool(self.success)
11907 
      oprot.writeFieldEnd()
11908 
    if self.cex is not None:
11909 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11910 
      self.cex.write(oprot)
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 checkSimilarItem_args:
11931 
  """
11932 
  Attributes:
11933 
   - brand
11934 
   - modelNumber
11935 
   - modelName
11936 
   - color
11937 
  """
11938 
 
11939 
  thrift_spec = (
11940 
    None, # 0
11941 
    (1, TType.STRING, 'brand', None, None, ), # 1
11942 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11943 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11944 
    (4, TType.STRING, 'color', None, None, ), # 4
11945 
  )
11946 
 
11947 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11948 
    self.brand = brand
11949 
    self.modelNumber = modelNumber
11950 
    self.modelName = modelName
11951 
    self.color = color
11952 
 
11953 
  def read(self, iprot):
11954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11956 
      return
11957 
    iprot.readStructBegin()
11958 
    while True:
11959 
      (fname, ftype, fid) = iprot.readFieldBegin()
11960 
      if ftype == TType.STOP:
11961 
        break
11962 
      if fid == 1:
11963 
        if ftype == TType.STRING:
11964 
          self.brand = iprot.readString();
11965 
        else:
11966 
          iprot.skip(ftype)
11967 
      elif fid == 2:
11968 
        if ftype == TType.STRING:
11969 
          self.modelNumber = iprot.readString();
11970 
        else:
11971 
          iprot.skip(ftype)
11972 
      elif fid == 3:
11973 
        if ftype == TType.STRING:
11974 
          self.modelName = iprot.readString();
11975 
        else:
11976 
          iprot.skip(ftype)
11977 
      elif fid == 4:
11978 
        if ftype == TType.STRING:
11979 
          self.color = iprot.readString();
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      else:
11983 
        iprot.skip(ftype)
11984 
      iprot.readFieldEnd()
11985 
    iprot.readStructEnd()
11986 
 
11987 
  def write(self, oprot):
11988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11990 
      return
11991 
    oprot.writeStructBegin('checkSimilarItem_args')
11992 
    if self.brand is not None:
11993 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11994 
      oprot.writeString(self.brand)
11995 
      oprot.writeFieldEnd()
11996 
    if self.modelNumber is not None:
11997 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11998 
      oprot.writeString(self.modelNumber)
11999 
      oprot.writeFieldEnd()
12000 
    if self.modelName is not None:
12001 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12002 
      oprot.writeString(self.modelName)
12003 
      oprot.writeFieldEnd()
12004 
    if self.color is not None:
12005 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12006 
      oprot.writeString(self.color)
12007 
      oprot.writeFieldEnd()
12008 
    oprot.writeFieldStop()
12009 
    oprot.writeStructEnd()
12010 
 
12011 
  def validate(self):
12012 
    return
12013 
 
12014 
 
12015 
  def __repr__(self):
12016 
    L = ['%s=%r' % (key, value)
12017 
      for key, value in self.__dict__.iteritems()]
12018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12019 
 
12020 
  def __eq__(self, other):
12021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12022 
 
12023 
  def __ne__(self, other):
12024 
    return not (self == other)
12025 
 
12026 
class checkSimilarItem_result:
12027 
  """
12028 
  Attributes:
12029 
   - success
12030 
  """
12031 
 
12032 
  thrift_spec = (
12033 
    (0, TType.I64, 'success', None, None, ), # 0
12034 
  )
12035 
 
12036 
  def __init__(self, success=None,):
12037 
    self.success = success
12038 
 
12039 
  def read(self, iprot):
12040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12042 
      return
12043 
    iprot.readStructBegin()
12044 
    while True:
12045 
      (fname, ftype, fid) = iprot.readFieldBegin()
12046 
      if ftype == TType.STOP:
12047 
        break
12048 
      if fid == 0:
12049 
        if ftype == TType.I64:
12050 
          self.success = iprot.readI64();
12051 
        else:
12052 
          iprot.skip(ftype)
12053 
      else:
12054 
        iprot.skip(ftype)
12055 
      iprot.readFieldEnd()
12056 
    iprot.readStructEnd()
12057 
 
12058 
  def write(self, oprot):
12059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12061 
      return
12062 
    oprot.writeStructBegin('checkSimilarItem_result')
12063 
    if self.success is not None:
12064 
      oprot.writeFieldBegin('success', TType.I64, 0)
12065 
      oprot.writeI64(self.success)
12066 
      oprot.writeFieldEnd()
12067 
    oprot.writeFieldStop()
12068 
    oprot.writeStructEnd()
12069 
 
12070 
  def validate(self):
12071 
    return
12072 
 
12073 
 
12074 
  def __repr__(self):
12075 
    L = ['%s=%r' % (key, value)
12076 
      for key, value in self.__dict__.iteritems()]
12077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12078 
 
12079 
  def __eq__(self, other):
12080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12081 
 
12082 
  def __ne__(self, other):
12083 
    return not (self == other)
12084 
 
12085 
class validateRiskyStatus_args:
12086 
  """
12087 
  Attributes:
12088 
   - itemId
12089 
  """
12090 
 
12091 
  thrift_spec = (
12092 
    None, # 0
12093 
    (1, TType.I64, 'itemId', None, None, ), # 1
12094 
  )
12095 
 
12096 
  def __init__(self, itemId=None,):
12097 
    self.itemId = itemId
12098 
 
12099 
  def read(self, iprot):
12100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12102 
      return
12103 
    iprot.readStructBegin()
12104 
    while True:
12105 
      (fname, ftype, fid) = iprot.readFieldBegin()
12106 
      if ftype == TType.STOP:
12107 
        break
12108 
      if fid == 1:
12109 
        if ftype == TType.I64:
12110 
          self.itemId = iprot.readI64();
12111 
        else:
12112 
          iprot.skip(ftype)
12113 
      else:
12114 
        iprot.skip(ftype)
12115 
      iprot.readFieldEnd()
12116 
    iprot.readStructEnd()
12117 
 
12118 
  def write(self, oprot):
12119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12121 
      return
12122 
    oprot.writeStructBegin('validateRiskyStatus_args')
12123 
    if self.itemId is not None:
12124 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12125 
      oprot.writeI64(self.itemId)
12126 
      oprot.writeFieldEnd()
12127 
    oprot.writeFieldStop()
12128 
    oprot.writeStructEnd()
12129 
 
12130 
  def validate(self):
12131 
    return
12132 
 
12133 
 
12134 
  def __repr__(self):
12135 
    L = ['%s=%r' % (key, value)
12136 
      for key, value in self.__dict__.iteritems()]
12137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12138 
 
12139 
  def __eq__(self, other):
12140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12141 
 
12142 
  def __ne__(self, other):
12143 
    return not (self == other)
12144 
 
12145 
class validateRiskyStatus_result:
12146 
 
12147 
  thrift_spec = (
12148 
  )
12149 
 
12150 
  def read(self, iprot):
12151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12153 
      return
12154 
    iprot.readStructBegin()
12155 
    while True:
12156 
      (fname, ftype, fid) = iprot.readFieldBegin()
12157 
      if ftype == TType.STOP:
12158 
        break
12159 
      else:
12160 
        iprot.skip(ftype)
12161 
      iprot.readFieldEnd()
12162 
    iprot.readStructEnd()
12163 
 
12164 
  def write(self, oprot):
12165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12167 
      return
12168 
    oprot.writeStructBegin('validateRiskyStatus_result')
12169 
    oprot.writeFieldStop()
12170 
    oprot.writeStructEnd()
12171 
 
12172 
  def validate(self):
12173 
    return
12174 
 
12175 
 
12176 
  def __repr__(self):
12177 
    L = ['%s=%r' % (key, value)
12178 
      for key, value in self.__dict__.iteritems()]
12179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12180 
 
12181 
  def __eq__(self, other):
12182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12183 
 
12184 
  def __ne__(self, other):
12185 
    return not (self == other)
12186 
 
12187 
class changeItemRiskyFlag_args:
12188 
  """
12189 
  Attributes:
12190 
   - itemId
12191 
   - risky
12192 
  """
12193 
 
12194 
  thrift_spec = (
12195 
    None, # 0
12196 
    (1, TType.I64, 'itemId', None, None, ), # 1
12197 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12198 
  )
12199 
 
12200 
  def __init__(self, itemId=None, risky=None,):
12201 
    self.itemId = itemId
12202 
    self.risky = risky
12203 
 
12204 
  def read(self, iprot):
12205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12207 
      return
12208 
    iprot.readStructBegin()
12209 
    while True:
12210 
      (fname, ftype, fid) = iprot.readFieldBegin()
12211 
      if ftype == TType.STOP:
12212 
        break
12213 
      if fid == 1:
12214 
        if ftype == TType.I64:
12215 
          self.itemId = iprot.readI64();
12216 
        else:
12217 
          iprot.skip(ftype)
12218 
      elif fid == 2:
12219 
        if ftype == TType.BOOL:
12220 
          self.risky = iprot.readBool();
12221 
        else:
12222 
          iprot.skip(ftype)
12223 
      else:
12224 
        iprot.skip(ftype)
12225 
      iprot.readFieldEnd()
12226 
    iprot.readStructEnd()
12227 
 
12228 
  def write(self, oprot):
12229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12231 
      return
12232 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12233 
    if self.itemId is not None:
12234 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12235 
      oprot.writeI64(self.itemId)
12236 
      oprot.writeFieldEnd()
12237 
    if self.risky is not None:
12238 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12239 
      oprot.writeBool(self.risky)
12240 
      oprot.writeFieldEnd()
12241 
    oprot.writeFieldStop()
12242 
    oprot.writeStructEnd()
12243 
 
12244 
  def validate(self):
12245 
    return
12246 
 
12247 
 
12248 
  def __repr__(self):
12249 
    L = ['%s=%r' % (key, value)
12250 
      for key, value in self.__dict__.iteritems()]
12251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12252 
 
12253 
  def __eq__(self, other):
12254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12255 
 
12256 
  def __ne__(self, other):
12257 
    return not (self == other)
12258 
 
12259 
class changeItemRiskyFlag_result:
12260 
 
12261 
  thrift_spec = (
12262 
  )
12263 
 
12264 
  def read(self, iprot):
12265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12267 
      return
12268 
    iprot.readStructBegin()
12269 
    while True:
12270 
      (fname, ftype, fid) = iprot.readFieldBegin()
12271 
      if ftype == TType.STOP:
12272 
        break
12273 
      else:
12274 
        iprot.skip(ftype)
12275 
      iprot.readFieldEnd()
12276 
    iprot.readStructEnd()
12277 
 
12278 
  def write(self, oprot):
12279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12281 
      return
12282 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12283 
    oprot.writeFieldStop()
12284 
    oprot.writeStructEnd()
12285 
 
12286 
  def validate(self):
12287 
    return
12288 
 
12289 
 
12290 
  def __repr__(self):
12291 
    L = ['%s=%r' % (key, value)
12292 
      for key, value in self.__dict__.iteritems()]
12293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12294 
 
12295 
  def __eq__(self, other):
12296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12297 
 
12298 
  def __ne__(self, other):
12299 
    return not (self == other)
12300 
 
12301 
class getItemsByRiskyFlag_args:
12302 
 
12303 
  thrift_spec = (
12304 
  )
12305 
 
12306 
  def read(self, iprot):
12307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12309 
      return
12310 
    iprot.readStructBegin()
12311 
    while True:
12312 
      (fname, ftype, fid) = iprot.readFieldBegin()
12313 
      if ftype == TType.STOP:
12314 
        break
12315 
      else:
12316 
        iprot.skip(ftype)
12317 
      iprot.readFieldEnd()
12318 
    iprot.readStructEnd()
12319 
 
12320 
  def write(self, oprot):
12321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12323 
      return
12324 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12325 
    oprot.writeFieldStop()
12326 
    oprot.writeStructEnd()
12327 
 
12328 
  def validate(self):
12329 
    return
12330 
 
12331 
 
12332 
  def __repr__(self):
12333 
    L = ['%s=%r' % (key, value)
12334 
      for key, value in self.__dict__.iteritems()]
12335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12336 
 
12337 
  def __eq__(self, other):
12338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12339 
 
12340 
  def __ne__(self, other):
12341 
    return not (self == other)
12342 
 
12343 
class getItemsByRiskyFlag_result:
12344 
  """
12345 
  Attributes:
12346 
   - success
12347 
  """
12348 
 
12349 
  thrift_spec = (
12350 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12351 
  )
12352 
 
12353 
  def __init__(self, success=None,):
12354 
    self.success = success
12355 
 
12356 
  def read(self, iprot):
12357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12359 
      return
12360 
    iprot.readStructBegin()
12361 
    while True:
12362 
      (fname, ftype, fid) = iprot.readFieldBegin()
12363 
      if ftype == TType.STOP:
12364 
        break
12365 
      if fid == 0:
12366 
        if ftype == TType.LIST:
12367 
          self.success = []
7438 amit.gupta 12368 
          (_etype205, _size202) = iprot.readListBegin()
12369 
          for _i206 in xrange(_size202):
12370 
            _elem207 = Item()
12371 
            _elem207.read(iprot)
12372 
            self.success.append(_elem207)
5944 mandeep.dh 12373 
          iprot.readListEnd()
12374 
        else:
12375 
          iprot.skip(ftype)
12376 
      else:
12377 
        iprot.skip(ftype)
12378 
      iprot.readFieldEnd()
12379 
    iprot.readStructEnd()
12380 
 
12381 
  def write(self, oprot):
12382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12384 
      return
12385 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12386 
    if self.success is not None:
12387 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12388 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12389 
      for iter208 in self.success:
12390 
        iter208.write(oprot)
5944 mandeep.dh 12391 
      oprot.writeListEnd()
12392 
      oprot.writeFieldEnd()
12393 
    oprot.writeFieldStop()
12394 
    oprot.writeStructEnd()
12395 
 
12396 
  def validate(self):
12397 
    return
12398 
 
12399 
 
12400 
  def __repr__(self):
12401 
    L = ['%s=%r' % (key, value)
12402 
      for key, value in self.__dict__.iteritems()]
12403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12404 
 
12405 
  def __eq__(self, other):
12406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12407 
 
12408 
  def __ne__(self, other):
12409 
    return not (self == other)
12410 
 
12411 
class getItemsForMasterSheet_args:
12412 
  """
12413 
  Attributes:
12414 
   - category
12415 
   - brand
12416 
  """
12417 
 
12418 
  thrift_spec = (
12419 
    None, # 0
12420 
    (1, TType.STRING, 'category', None, None, ), # 1
12421 
    (2, TType.STRING, 'brand', None, None, ), # 2
12422 
  )
12423 
 
12424 
  def __init__(self, category=None, brand=None,):
12425 
    self.category = category
12426 
    self.brand = brand
12427 
 
12428 
  def read(self, iprot):
12429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12431 
      return
12432 
    iprot.readStructBegin()
12433 
    while True:
12434 
      (fname, ftype, fid) = iprot.readFieldBegin()
12435 
      if ftype == TType.STOP:
12436 
        break
12437 
      if fid == 1:
12438 
        if ftype == TType.STRING:
12439 
          self.category = iprot.readString();
12440 
        else:
12441 
          iprot.skip(ftype)
12442 
      elif fid == 2:
12443 
        if ftype == TType.STRING:
12444 
          self.brand = iprot.readString();
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      else:
12448 
        iprot.skip(ftype)
12449 
      iprot.readFieldEnd()
12450 
    iprot.readStructEnd()
12451 
 
12452 
  def write(self, oprot):
12453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12455 
      return
12456 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12457 
    if self.category is not None:
12458 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12459 
      oprot.writeString(self.category)
12460 
      oprot.writeFieldEnd()
12461 
    if self.brand is not None:
12462 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12463 
      oprot.writeString(self.brand)
12464 
      oprot.writeFieldEnd()
12465 
    oprot.writeFieldStop()
12466 
    oprot.writeStructEnd()
12467 
 
12468 
  def validate(self):
12469 
    return
12470 
 
12471 
 
12472 
  def __repr__(self):
12473 
    L = ['%s=%r' % (key, value)
12474 
      for key, value in self.__dict__.iteritems()]
12475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12476 
 
12477 
  def __eq__(self, other):
12478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12479 
 
12480 
  def __ne__(self, other):
12481 
    return not (self == other)
12482 
 
12483 
class getItemsForMasterSheet_result:
12484 
  """
12485 
  Attributes:
12486 
   - success
12487 
  """
12488 
 
12489 
  thrift_spec = (
12490 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12491 
  )
12492 
 
12493 
  def __init__(self, success=None,):
12494 
    self.success = success
12495 
 
12496 
  def read(self, iprot):
12497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12499 
      return
12500 
    iprot.readStructBegin()
12501 
    while True:
12502 
      (fname, ftype, fid) = iprot.readFieldBegin()
12503 
      if ftype == TType.STOP:
12504 
        break
12505 
      if fid == 0:
12506 
        if ftype == TType.LIST:
12507 
          self.success = []
7438 amit.gupta 12508 
          (_etype212, _size209) = iprot.readListBegin()
12509 
          for _i213 in xrange(_size209):
12510 
            _elem214 = Item()
12511 
            _elem214.read(iprot)
12512 
            self.success.append(_elem214)
5944 mandeep.dh 12513 
          iprot.readListEnd()
12514 
        else:
12515 
          iprot.skip(ftype)
12516 
      else:
12517 
        iprot.skip(ftype)
12518 
      iprot.readFieldEnd()
12519 
    iprot.readStructEnd()
12520 
 
12521 
  def write(self, oprot):
12522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12524 
      return
12525 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12526 
    if self.success is not None:
12527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12529 
      for iter215 in self.success:
12530 
        iter215.write(oprot)
5944 mandeep.dh 12531 
      oprot.writeListEnd()
12532 
      oprot.writeFieldEnd()
12533 
    oprot.writeFieldStop()
12534 
    oprot.writeStructEnd()
12535 
 
12536 
  def validate(self):
12537 
    return
12538 
 
12539 
 
12540 
  def __repr__(self):
12541 
    L = ['%s=%r' % (key, value)
12542 
      for key, value in self.__dict__.iteritems()]
12543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12544 
 
12545 
  def __eq__(self, other):
12546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12547 
 
12548 
  def __ne__(self, other):
12549 
    return not (self == other)
12550 
 
12551 
class getSimilarItemsCatalogIds_args:
12552 
  """
12553 
  Attributes:
12554 
   - beginIndex
12555 
   - totalItems
12556 
   - itemId
12557 
  """
12558 
 
12559 
  thrift_spec = (
12560 
    None, # 0
12561 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12562 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12563 
    (3, TType.I64, 'itemId', None, None, ), # 3
12564 
  )
12565 
 
12566 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12567 
    self.beginIndex = beginIndex
12568 
    self.totalItems = totalItems
12569 
    self.itemId = itemId
12570 
 
12571 
  def read(self, iprot):
12572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12574 
      return
12575 
    iprot.readStructBegin()
12576 
    while True:
12577 
      (fname, ftype, fid) = iprot.readFieldBegin()
12578 
      if ftype == TType.STOP:
12579 
        break
12580 
      if fid == 1:
12581 
        if ftype == TType.I64:
12582 
          self.beginIndex = iprot.readI64();
12583 
        else:
12584 
          iprot.skip(ftype)
12585 
      elif fid == 2:
12586 
        if ftype == TType.I64:
12587 
          self.totalItems = iprot.readI64();
12588 
        else:
12589 
          iprot.skip(ftype)
12590 
      elif fid == 3:
12591 
        if ftype == TType.I64:
12592 
          self.itemId = iprot.readI64();
12593 
        else:
12594 
          iprot.skip(ftype)
12595 
      else:
12596 
        iprot.skip(ftype)
12597 
      iprot.readFieldEnd()
12598 
    iprot.readStructEnd()
12599 
 
12600 
  def write(self, oprot):
12601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12603 
      return
12604 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12605 
    if self.beginIndex is not None:
12606 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12607 
      oprot.writeI64(self.beginIndex)
12608 
      oprot.writeFieldEnd()
12609 
    if self.totalItems is not None:
12610 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12611 
      oprot.writeI64(self.totalItems)
12612 
      oprot.writeFieldEnd()
12613 
    if self.itemId is not None:
12614 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12615 
      oprot.writeI64(self.itemId)
12616 
      oprot.writeFieldEnd()
12617 
    oprot.writeFieldStop()
12618 
    oprot.writeStructEnd()
12619 
 
12620 
  def validate(self):
12621 
    return
12622 
 
12623 
 
12624 
  def __repr__(self):
12625 
    L = ['%s=%r' % (key, value)
12626 
      for key, value in self.__dict__.iteritems()]
12627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12628 
 
12629 
  def __eq__(self, other):
12630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12631 
 
12632 
  def __ne__(self, other):
12633 
    return not (self == other)
12634 
 
12635 
class getSimilarItemsCatalogIds_result:
12636 
  """
12637 
  Attributes:
12638 
   - success
12639 
  """
12640 
 
12641 
  thrift_spec = (
12642 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12643 
  )
12644 
 
12645 
  def __init__(self, success=None,):
12646 
    self.success = success
12647 
 
12648 
  def read(self, iprot):
12649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12651 
      return
12652 
    iprot.readStructBegin()
12653 
    while True:
12654 
      (fname, ftype, fid) = iprot.readFieldBegin()
12655 
      if ftype == TType.STOP:
12656 
        break
12657 
      if fid == 0:
12658 
        if ftype == TType.LIST:
12659 
          self.success = []
7438 amit.gupta 12660 
          (_etype219, _size216) = iprot.readListBegin()
12661 
          for _i220 in xrange(_size216):
12662 
            _elem221 = iprot.readI64();
12663 
            self.success.append(_elem221)
5944 mandeep.dh 12664 
          iprot.readListEnd()
12665 
        else:
12666 
          iprot.skip(ftype)
12667 
      else:
12668 
        iprot.skip(ftype)
12669 
      iprot.readFieldEnd()
12670 
    iprot.readStructEnd()
12671 
 
12672 
  def write(self, oprot):
12673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12675 
      return
12676 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12677 
    if self.success is not None:
12678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12679 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12680 
      for iter222 in self.success:
12681 
        oprot.writeI64(iter222)
5944 mandeep.dh 12682 
      oprot.writeListEnd()
12683 
      oprot.writeFieldEnd()
12684 
    oprot.writeFieldStop()
12685 
    oprot.writeStructEnd()
12686 
 
12687 
  def validate(self):
12688 
    return
12689 
 
12690 
 
12691 
  def __repr__(self):
12692 
    L = ['%s=%r' % (key, value)
12693 
      for key, value in self.__dict__.iteritems()]
12694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12695 
 
12696 
  def __eq__(self, other):
12697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12698 
 
12699 
  def __ne__(self, other):
12700 
    return not (self == other)
12701 
 
12702 
class addProductNotification_args:
12703 
  """
12704 
  Attributes:
12705 
   - itemId
12706 
   - email
12707 
  """
12708 
 
12709 
  thrift_spec = None
12710 
  def __init__(self, itemId=None, email=None,):
12711 
    self.itemId = itemId
12712 
    self.email = email
12713 
 
12714 
  def read(self, iprot):
12715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12717 
      return
12718 
    iprot.readStructBegin()
12719 
    while True:
12720 
      (fname, ftype, fid) = iprot.readFieldBegin()
12721 
      if ftype == TType.STOP:
12722 
        break
12723 
      if fid == -1:
12724 
        if ftype == TType.I64:
12725 
          self.itemId = iprot.readI64();
12726 
        else:
12727 
          iprot.skip(ftype)
12728 
      elif fid == -2:
12729 
        if ftype == TType.STRING:
12730 
          self.email = iprot.readString();
12731 
        else:
12732 
          iprot.skip(ftype)
12733 
      else:
12734 
        iprot.skip(ftype)
12735 
      iprot.readFieldEnd()
12736 
    iprot.readStructEnd()
12737 
 
12738 
  def write(self, oprot):
12739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12741 
      return
12742 
    oprot.writeStructBegin('addProductNotification_args')
12743 
    if self.email is not None:
12744 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12745 
      oprot.writeString(self.email)
12746 
      oprot.writeFieldEnd()
12747 
    if self.itemId is not None:
12748 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12749 
      oprot.writeI64(self.itemId)
12750 
      oprot.writeFieldEnd()
12751 
    oprot.writeFieldStop()
12752 
    oprot.writeStructEnd()
12753 
 
12754 
  def validate(self):
12755 
    return
12756 
 
12757 
 
12758 
  def __repr__(self):
12759 
    L = ['%s=%r' % (key, value)
12760 
      for key, value in self.__dict__.iteritems()]
12761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12762 
 
12763 
  def __eq__(self, other):
12764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12765 
 
12766 
  def __ne__(self, other):
12767 
    return not (self == other)
12768 
 
12769 
class addProductNotification_result:
12770 
  """
12771 
  Attributes:
12772 
   - success
12773 
  """
12774 
 
12775 
  thrift_spec = (
12776 
    (0, TType.BOOL, 'success', None, None, ), # 0
12777 
  )
12778 
 
12779 
  def __init__(self, success=None,):
12780 
    self.success = success
12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      if fid == 0:
12792 
        if ftype == TType.BOOL:
12793 
          self.success = iprot.readBool();
12794 
        else:
12795 
          iprot.skip(ftype)
12796 
      else:
12797 
        iprot.skip(ftype)
12798 
      iprot.readFieldEnd()
12799 
    iprot.readStructEnd()
12800 
 
12801 
  def write(self, oprot):
12802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12804 
      return
12805 
    oprot.writeStructBegin('addProductNotification_result')
12806 
    if self.success is not None:
12807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12808 
      oprot.writeBool(self.success)
12809 
      oprot.writeFieldEnd()
12810 
    oprot.writeFieldStop()
12811 
    oprot.writeStructEnd()
12812 
 
12813 
  def validate(self):
12814 
    return
12815 
 
12816 
 
12817 
  def __repr__(self):
12818 
    L = ['%s=%r' % (key, value)
12819 
      for key, value in self.__dict__.iteritems()]
12820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12821 
 
12822 
  def __eq__(self, other):
12823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12824 
 
12825 
  def __ne__(self, other):
12826 
    return not (self == other)
12827 
 
12828 
class sendProductNotifications_args:
12829 
 
12830 
  thrift_spec = (
12831 
  )
12832 
 
12833 
  def read(self, iprot):
12834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12836 
      return
12837 
    iprot.readStructBegin()
12838 
    while True:
12839 
      (fname, ftype, fid) = iprot.readFieldBegin()
12840 
      if ftype == TType.STOP:
12841 
        break
12842 
      else:
12843 
        iprot.skip(ftype)
12844 
      iprot.readFieldEnd()
12845 
    iprot.readStructEnd()
12846 
 
12847 
  def write(self, oprot):
12848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12850 
      return
12851 
    oprot.writeStructBegin('sendProductNotifications_args')
12852 
    oprot.writeFieldStop()
12853 
    oprot.writeStructEnd()
12854 
 
12855 
  def validate(self):
12856 
    return
12857 
 
12858 
 
12859 
  def __repr__(self):
12860 
    L = ['%s=%r' % (key, value)
12861 
      for key, value in self.__dict__.iteritems()]
12862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12863 
 
12864 
  def __eq__(self, other):
12865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12866 
 
12867 
  def __ne__(self, other):
12868 
    return not (self == other)
12869 
 
12870 
class sendProductNotifications_result:
12871 
  """
12872 
  Attributes:
12873 
   - success
12874 
  """
12875 
 
12876 
  thrift_spec = (
12877 
    (0, TType.BOOL, 'success', None, None, ), # 0
12878 
  )
12879 
 
12880 
  def __init__(self, success=None,):
12881 
    self.success = success
12882 
 
12883 
  def read(self, iprot):
12884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12886 
      return
12887 
    iprot.readStructBegin()
12888 
    while True:
12889 
      (fname, ftype, fid) = iprot.readFieldBegin()
12890 
      if ftype == TType.STOP:
12891 
        break
12892 
      if fid == 0:
12893 
        if ftype == TType.BOOL:
12894 
          self.success = iprot.readBool();
12895 
        else:
12896 
          iprot.skip(ftype)
12897 
      else:
12898 
        iprot.skip(ftype)
12899 
      iprot.readFieldEnd()
12900 
    iprot.readStructEnd()
12901 
 
12902 
  def write(self, oprot):
12903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12905 
      return
12906 
    oprot.writeStructBegin('sendProductNotifications_result')
12907 
    if self.success is not None:
12908 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12909 
      oprot.writeBool(self.success)
12910 
      oprot.writeFieldEnd()
12911 
    oprot.writeFieldStop()
12912 
    oprot.writeStructEnd()
12913 
 
12914 
  def validate(self):
12915 
    return
12916 
 
12917 
 
12918 
  def __repr__(self):
12919 
    L = ['%s=%r' % (key, value)
12920 
      for key, value in self.__dict__.iteritems()]
12921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12922 
 
12923 
  def __eq__(self, other):
12924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12925 
 
12926 
  def __ne__(self, other):
12927 
    return not (self == other)
12928 
 
12929 
class getAllBrandsByCategory_args:
12930 
  """
12931 
  Attributes:
12932 
   - categoryId
12933 
  """
12934 
 
12935 
  thrift_spec = (
12936 
    None, # 0
12937 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12938 
  )
12939 
 
12940 
  def __init__(self, categoryId=None,):
12941 
    self.categoryId = categoryId
12942 
 
12943 
  def read(self, iprot):
12944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12946 
      return
12947 
    iprot.readStructBegin()
12948 
    while True:
12949 
      (fname, ftype, fid) = iprot.readFieldBegin()
12950 
      if ftype == TType.STOP:
12951 
        break
12952 
      if fid == 1:
12953 
        if ftype == TType.I64:
12954 
          self.categoryId = iprot.readI64();
12955 
        else:
12956 
          iprot.skip(ftype)
12957 
      else:
12958 
        iprot.skip(ftype)
12959 
      iprot.readFieldEnd()
12960 
    iprot.readStructEnd()
12961 
 
12962 
  def write(self, oprot):
12963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12965 
      return
12966 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12967 
    if self.categoryId is not None:
12968 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12969 
      oprot.writeI64(self.categoryId)
12970 
      oprot.writeFieldEnd()
12971 
    oprot.writeFieldStop()
12972 
    oprot.writeStructEnd()
12973 
 
12974 
  def validate(self):
12975 
    return
12976 
 
12977 
 
12978 
  def __repr__(self):
12979 
    L = ['%s=%r' % (key, value)
12980 
      for key, value in self.__dict__.iteritems()]
12981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12982 
 
12983 
  def __eq__(self, other):
12984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12985 
 
12986 
  def __ne__(self, other):
12987 
    return not (self == other)
12988 
 
12989 
class getAllBrandsByCategory_result:
12990 
  """
12991 
  Attributes:
12992 
   - success
12993 
  """
12994 
 
12995 
  thrift_spec = (
12996 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12997 
  )
12998 
 
12999 
  def __init__(self, success=None,):
13000 
    self.success = success
13001 
 
13002 
  def read(self, iprot):
13003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13005 
      return
13006 
    iprot.readStructBegin()
13007 
    while True:
13008 
      (fname, ftype, fid) = iprot.readFieldBegin()
13009 
      if ftype == TType.STOP:
13010 
        break
13011 
      if fid == 0:
13012 
        if ftype == TType.LIST:
13013 
          self.success = []
7438 amit.gupta 13014 
          (_etype226, _size223) = iprot.readListBegin()
13015 
          for _i227 in xrange(_size223):
13016 
            _elem228 = iprot.readString();
13017 
            self.success.append(_elem228)
5944 mandeep.dh 13018 
          iprot.readListEnd()
13019 
        else:
13020 
          iprot.skip(ftype)
13021 
      else:
13022 
        iprot.skip(ftype)
13023 
      iprot.readFieldEnd()
13024 
    iprot.readStructEnd()
13025 
 
13026 
  def write(self, oprot):
13027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13029 
      return
13030 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
13031 
    if self.success is not None:
13032 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13033 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13034 
      for iter229 in self.success:
13035 
        oprot.writeString(iter229)
5944 mandeep.dh 13036 
      oprot.writeListEnd()
13037 
      oprot.writeFieldEnd()
13038 
    oprot.writeFieldStop()
13039 
    oprot.writeStructEnd()
13040 
 
13041 
  def validate(self):
13042 
    return
13043 
 
13044 
 
13045 
  def __repr__(self):
13046 
    L = ['%s=%r' % (key, value)
13047 
      for key, value in self.__dict__.iteritems()]
13048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13049 
 
13050 
  def __eq__(self, other):
13051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13052 
 
13053 
  def __ne__(self, other):
13054 
    return not (self == other)
13055 
 
13056 
class getAllBrands_args:
13057 
 
13058 
  thrift_spec = (
13059 
  )
13060 
 
13061 
  def read(self, iprot):
13062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13064 
      return
13065 
    iprot.readStructBegin()
13066 
    while True:
13067 
      (fname, ftype, fid) = iprot.readFieldBegin()
13068 
      if ftype == TType.STOP:
13069 
        break
13070 
      else:
13071 
        iprot.skip(ftype)
13072 
      iprot.readFieldEnd()
13073 
    iprot.readStructEnd()
13074 
 
13075 
  def write(self, oprot):
13076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13078 
      return
13079 
    oprot.writeStructBegin('getAllBrands_args')
13080 
    oprot.writeFieldStop()
13081 
    oprot.writeStructEnd()
13082 
 
13083 
  def validate(self):
13084 
    return
13085 
 
13086 
 
13087 
  def __repr__(self):
13088 
    L = ['%s=%r' % (key, value)
13089 
      for key, value in self.__dict__.iteritems()]
13090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13091 
 
13092 
  def __eq__(self, other):
13093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13094 
 
13095 
  def __ne__(self, other):
13096 
    return not (self == other)
13097 
 
13098 
class getAllBrands_result:
13099 
  """
13100 
  Attributes:
13101 
   - success
13102 
  """
13103 
 
13104 
  thrift_spec = (
13105 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13106 
  )
13107 
 
13108 
  def __init__(self, success=None,):
13109 
    self.success = success
13110 
 
13111 
  def read(self, iprot):
13112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13114 
      return
13115 
    iprot.readStructBegin()
13116 
    while True:
13117 
      (fname, ftype, fid) = iprot.readFieldBegin()
13118 
      if ftype == TType.STOP:
13119 
        break
13120 
      if fid == 0:
13121 
        if ftype == TType.LIST:
13122 
          self.success = []
7438 amit.gupta 13123 
          (_etype233, _size230) = iprot.readListBegin()
13124 
          for _i234 in xrange(_size230):
13125 
            _elem235 = iprot.readString();
13126 
            self.success.append(_elem235)
5944 mandeep.dh 13127 
          iprot.readListEnd()
13128 
        else:
13129 
          iprot.skip(ftype)
13130 
      else:
13131 
        iprot.skip(ftype)
13132 
      iprot.readFieldEnd()
13133 
    iprot.readStructEnd()
13134 
 
13135 
  def write(self, oprot):
13136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13138 
      return
13139 
    oprot.writeStructBegin('getAllBrands_result')
13140 
    if self.success is not None:
13141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13142 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13143 
      for iter236 in self.success:
13144 
        oprot.writeString(iter236)
5944 mandeep.dh 13145 
      oprot.writeListEnd()
13146 
      oprot.writeFieldEnd()
13147 
    oprot.writeFieldStop()
13148 
    oprot.writeStructEnd()
13149 
 
13150 
  def validate(self):
13151 
    return
13152 
 
13153 
 
13154 
  def __repr__(self):
13155 
    L = ['%s=%r' % (key, value)
13156 
      for key, value in self.__dict__.iteritems()]
13157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13158 
 
13159 
  def __eq__(self, other):
13160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13161 
 
13162 
  def __ne__(self, other):
13163 
    return not (self == other)
13164 
 
13165 
class getAllSources_args:
13166 
 
13167 
  thrift_spec = (
13168 
  )
13169 
 
13170 
  def read(self, iprot):
13171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13173 
      return
13174 
    iprot.readStructBegin()
13175 
    while True:
13176 
      (fname, ftype, fid) = iprot.readFieldBegin()
13177 
      if ftype == TType.STOP:
13178 
        break
13179 
      else:
13180 
        iprot.skip(ftype)
13181 
      iprot.readFieldEnd()
13182 
    iprot.readStructEnd()
13183 
 
13184 
  def write(self, oprot):
13185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13187 
      return
13188 
    oprot.writeStructBegin('getAllSources_args')
13189 
    oprot.writeFieldStop()
13190 
    oprot.writeStructEnd()
13191 
 
13192 
  def validate(self):
13193 
    return
13194 
 
13195 
 
13196 
  def __repr__(self):
13197 
    L = ['%s=%r' % (key, value)
13198 
      for key, value in self.__dict__.iteritems()]
13199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13200 
 
13201 
  def __eq__(self, other):
13202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13203 
 
13204 
  def __ne__(self, other):
13205 
    return not (self == other)
13206 
 
13207 
class getAllSources_result:
13208 
  """
13209 
  Attributes:
13210 
   - success
13211 
  """
13212 
 
13213 
  thrift_spec = (
13214 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13215 
  )
13216 
 
13217 
  def __init__(self, success=None,):
13218 
    self.success = success
13219 
 
13220 
  def read(self, iprot):
13221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13223 
      return
13224 
    iprot.readStructBegin()
13225 
    while True:
13226 
      (fname, ftype, fid) = iprot.readFieldBegin()
13227 
      if ftype == TType.STOP:
13228 
        break
13229 
      if fid == 0:
13230 
        if ftype == TType.LIST:
13231 
          self.success = []
7438 amit.gupta 13232 
          (_etype240, _size237) = iprot.readListBegin()
13233 
          for _i241 in xrange(_size237):
13234 
            _elem242 = Source()
13235 
            _elem242.read(iprot)
13236 
            self.success.append(_elem242)
5944 mandeep.dh 13237 
          iprot.readListEnd()
13238 
        else:
13239 
          iprot.skip(ftype)
13240 
      else:
13241 
        iprot.skip(ftype)
13242 
      iprot.readFieldEnd()
13243 
    iprot.readStructEnd()
13244 
 
13245 
  def write(self, oprot):
13246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13248 
      return
13249 
    oprot.writeStructBegin('getAllSources_result')
13250 
    if self.success is not None:
13251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13252 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13253 
      for iter243 in self.success:
13254 
        iter243.write(oprot)
5944 mandeep.dh 13255 
      oprot.writeListEnd()
13256 
      oprot.writeFieldEnd()
13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
13275 
class getItemPricingBySource_args:
13276 
  """
13277 
  Attributes:
13278 
   - itemId
13279 
   - sourceId
13280 
  """
13281 
 
13282 
  thrift_spec = (
13283 
    None, # 0
13284 
    (1, TType.I64, 'itemId', None, None, ), # 1
13285 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13286 
  )
13287 
 
13288 
  def __init__(self, itemId=None, sourceId=None,):
13289 
    self.itemId = itemId
13290 
    self.sourceId = sourceId
13291 
 
13292 
  def read(self, iprot):
13293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13295 
      return
13296 
    iprot.readStructBegin()
13297 
    while True:
13298 
      (fname, ftype, fid) = iprot.readFieldBegin()
13299 
      if ftype == TType.STOP:
13300 
        break
13301 
      if fid == 1:
13302 
        if ftype == TType.I64:
13303 
          self.itemId = iprot.readI64();
13304 
        else:
13305 
          iprot.skip(ftype)
13306 
      elif fid == 2:
13307 
        if ftype == TType.I64:
13308 
          self.sourceId = iprot.readI64();
13309 
        else:
13310 
          iprot.skip(ftype)
13311 
      else:
13312 
        iprot.skip(ftype)
13313 
      iprot.readFieldEnd()
13314 
    iprot.readStructEnd()
13315 
 
13316 
  def write(self, oprot):
13317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13319 
      return
13320 
    oprot.writeStructBegin('getItemPricingBySource_args')
13321 
    if self.itemId is not None:
13322 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13323 
      oprot.writeI64(self.itemId)
13324 
      oprot.writeFieldEnd()
13325 
    if self.sourceId is not None:
13326 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13327 
      oprot.writeI64(self.sourceId)
13328 
      oprot.writeFieldEnd()
13329 
    oprot.writeFieldStop()
13330 
    oprot.writeStructEnd()
13331 
 
13332 
  def validate(self):
13333 
    return
13334 
 
13335 
 
13336 
  def __repr__(self):
13337 
    L = ['%s=%r' % (key, value)
13338 
      for key, value in self.__dict__.iteritems()]
13339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13340 
 
13341 
  def __eq__(self, other):
13342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13343 
 
13344 
  def __ne__(self, other):
13345 
    return not (self == other)
13346 
 
13347 
class getItemPricingBySource_result:
13348 
  """
13349 
  Attributes:
13350 
   - success
13351 
   - cex
13352 
  """
13353 
 
13354 
  thrift_spec = (
13355 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13356 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13357 
  )
13358 
 
13359 
  def __init__(self, success=None, cex=None,):
13360 
    self.success = success
13361 
    self.cex = cex
13362 
 
13363 
  def read(self, iprot):
13364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13366 
      return
13367 
    iprot.readStructBegin()
13368 
    while True:
13369 
      (fname, ftype, fid) = iprot.readFieldBegin()
13370 
      if ftype == TType.STOP:
13371 
        break
13372 
      if fid == 0:
13373 
        if ftype == TType.STRUCT:
13374 
          self.success = SourceItemPricing()
13375 
          self.success.read(iprot)
13376 
        else:
13377 
          iprot.skip(ftype)
13378 
      elif fid == 1:
13379 
        if ftype == TType.STRUCT:
13380 
          self.cex = CatalogServiceException()
13381 
          self.cex.read(iprot)
13382 
        else:
13383 
          iprot.skip(ftype)
13384 
      else:
13385 
        iprot.skip(ftype)
13386 
      iprot.readFieldEnd()
13387 
    iprot.readStructEnd()
13388 
 
13389 
  def write(self, oprot):
13390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13392 
      return
13393 
    oprot.writeStructBegin('getItemPricingBySource_result')
13394 
    if self.success is not None:
13395 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13396 
      self.success.write(oprot)
13397 
      oprot.writeFieldEnd()
13398 
    if self.cex is not None:
13399 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13400 
      self.cex.write(oprot)
13401 
      oprot.writeFieldEnd()
13402 
    oprot.writeFieldStop()
13403 
    oprot.writeStructEnd()
13404 
 
13405 
  def validate(self):
13406 
    return
13407 
 
13408 
 
13409 
  def __repr__(self):
13410 
    L = ['%s=%r' % (key, value)
13411 
      for key, value in self.__dict__.iteritems()]
13412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13413 
 
13414 
  def __eq__(self, other):
13415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13416 
 
13417 
  def __ne__(self, other):
13418 
    return not (self == other)
13419 
 
13420 
class addSourceItemPricing_args:
13421 
  """
13422 
  Attributes:
13423 
   - sourceItemPricing
13424 
  """
13425 
 
13426 
  thrift_spec = (
13427 
    None, # 0
13428 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13429 
  )
13430 
 
13431 
  def __init__(self, sourceItemPricing=None,):
13432 
    self.sourceItemPricing = sourceItemPricing
13433 
 
13434 
  def read(self, iprot):
13435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13437 
      return
13438 
    iprot.readStructBegin()
13439 
    while True:
13440 
      (fname, ftype, fid) = iprot.readFieldBegin()
13441 
      if ftype == TType.STOP:
13442 
        break
13443 
      if fid == 1:
13444 
        if ftype == TType.STRUCT:
13445 
          self.sourceItemPricing = SourceItemPricing()
13446 
          self.sourceItemPricing.read(iprot)
13447 
        else:
13448 
          iprot.skip(ftype)
13449 
      else:
13450 
        iprot.skip(ftype)
13451 
      iprot.readFieldEnd()
13452 
    iprot.readStructEnd()
13453 
 
13454 
  def write(self, oprot):
13455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13457 
      return
13458 
    oprot.writeStructBegin('addSourceItemPricing_args')
13459 
    if self.sourceItemPricing is not None:
13460 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13461 
      self.sourceItemPricing.write(oprot)
13462 
      oprot.writeFieldEnd()
13463 
    oprot.writeFieldStop()
13464 
    oprot.writeStructEnd()
13465 
 
13466 
  def validate(self):
13467 
    return
13468 
 
13469 
 
13470 
  def __repr__(self):
13471 
    L = ['%s=%r' % (key, value)
13472 
      for key, value in self.__dict__.iteritems()]
13473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13474 
 
13475 
  def __eq__(self, other):
13476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13477 
 
13478 
  def __ne__(self, other):
13479 
    return not (self == other)
13480 
 
13481 
class addSourceItemPricing_result:
13482 
  """
13483 
  Attributes:
13484 
   - cex
13485 
  """
13486 
 
13487 
  thrift_spec = (
13488 
    None, # 0
13489 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13490 
  )
13491 
 
13492 
  def __init__(self, cex=None,):
13493 
    self.cex = cex
13494 
 
13495 
  def read(self, iprot):
13496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13498 
      return
13499 
    iprot.readStructBegin()
13500 
    while True:
13501 
      (fname, ftype, fid) = iprot.readFieldBegin()
13502 
      if ftype == TType.STOP:
13503 
        break
13504 
      if fid == 1:
13505 
        if ftype == TType.STRUCT:
13506 
          self.cex = CatalogServiceException()
13507 
          self.cex.read(iprot)
13508 
        else:
13509 
          iprot.skip(ftype)
13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('addSourceItemPricing_result')
13520 
    if self.cex is not None:
13521 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13522 
      self.cex.write(oprot)
13523 
      oprot.writeFieldEnd()
13524 
    oprot.writeFieldStop()
13525 
    oprot.writeStructEnd()
13526 
 
13527 
  def validate(self):
13528 
    return
13529 
 
13530 
 
13531 
  def __repr__(self):
13532 
    L = ['%s=%r' % (key, value)
13533 
      for key, value in self.__dict__.iteritems()]
13534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13535 
 
13536 
  def __eq__(self, other):
13537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13538 
 
13539 
  def __ne__(self, other):
13540 
    return not (self == other)
13541 
 
13542 
class getAllSourcePricing_args:
13543 
  """
13544 
  Attributes:
13545 
   - itemId
13546 
  """
13547 
 
13548 
  thrift_spec = (
13549 
    None, # 0
13550 
    (1, TType.I64, 'itemId', None, None, ), # 1
13551 
  )
13552 
 
13553 
  def __init__(self, itemId=None,):
13554 
    self.itemId = itemId
13555 
 
13556 
  def read(self, iprot):
13557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13559 
      return
13560 
    iprot.readStructBegin()
13561 
    while True:
13562 
      (fname, ftype, fid) = iprot.readFieldBegin()
13563 
      if ftype == TType.STOP:
13564 
        break
13565 
      if fid == 1:
13566 
        if ftype == TType.I64:
13567 
          self.itemId = iprot.readI64();
13568 
        else:
13569 
          iprot.skip(ftype)
13570 
      else:
13571 
        iprot.skip(ftype)
13572 
      iprot.readFieldEnd()
13573 
    iprot.readStructEnd()
13574 
 
13575 
  def write(self, oprot):
13576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13578 
      return
13579 
    oprot.writeStructBegin('getAllSourcePricing_args')
13580 
    if self.itemId is not None:
13581 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13582 
      oprot.writeI64(self.itemId)
13583 
      oprot.writeFieldEnd()
13584 
    oprot.writeFieldStop()
13585 
    oprot.writeStructEnd()
13586 
 
13587 
  def validate(self):
13588 
    return
13589 
 
13590 
 
13591 
  def __repr__(self):
13592 
    L = ['%s=%r' % (key, value)
13593 
      for key, value in self.__dict__.iteritems()]
13594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13595 
 
13596 
  def __eq__(self, other):
13597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13598 
 
13599 
  def __ne__(self, other):
13600 
    return not (self == other)
13601 
 
13602 
class getAllSourcePricing_result:
13603 
  """
13604 
  Attributes:
13605 
   - success
13606 
   - cex
13607 
  """
13608 
 
13609 
  thrift_spec = (
13610 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13611 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13612 
  )
13613 
 
13614 
  def __init__(self, success=None, cex=None,):
13615 
    self.success = success
13616 
    self.cex = cex
13617 
 
13618 
  def read(self, iprot):
13619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13621 
      return
13622 
    iprot.readStructBegin()
13623 
    while True:
13624 
      (fname, ftype, fid) = iprot.readFieldBegin()
13625 
      if ftype == TType.STOP:
13626 
        break
13627 
      if fid == 0:
13628 
        if ftype == TType.LIST:
13629 
          self.success = []
7438 amit.gupta 13630 
          (_etype247, _size244) = iprot.readListBegin()
13631 
          for _i248 in xrange(_size244):
13632 
            _elem249 = SourceItemPricing()
13633 
            _elem249.read(iprot)
13634 
            self.success.append(_elem249)
5944 mandeep.dh 13635 
          iprot.readListEnd()
13636 
        else:
13637 
          iprot.skip(ftype)
13638 
      elif fid == 1:
13639 
        if ftype == TType.STRUCT:
13640 
          self.cex = CatalogServiceException()
13641 
          self.cex.read(iprot)
13642 
        else:
13643 
          iprot.skip(ftype)
13644 
      else:
13645 
        iprot.skip(ftype)
13646 
      iprot.readFieldEnd()
13647 
    iprot.readStructEnd()
13648 
 
13649 
  def write(self, oprot):
13650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13652 
      return
13653 
    oprot.writeStructBegin('getAllSourcePricing_result')
13654 
    if self.success is not None:
13655 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13656 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13657 
      for iter250 in self.success:
13658 
        iter250.write(oprot)
5944 mandeep.dh 13659 
      oprot.writeListEnd()
13660 
      oprot.writeFieldEnd()
13661 
    if self.cex is not None:
13662 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13663 
      self.cex.write(oprot)
13664 
      oprot.writeFieldEnd()
13665 
    oprot.writeFieldStop()
13666 
    oprot.writeStructEnd()
13667 
 
13668 
  def validate(self):
13669 
    return
13670 
 
13671 
 
13672 
  def __repr__(self):
13673 
    L = ['%s=%r' % (key, value)
13674 
      for key, value in self.__dict__.iteritems()]
13675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13676 
 
13677 
  def __eq__(self, other):
13678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13679 
 
13680 
  def __ne__(self, other):
13681 
    return not (self == other)
13682 
 
13683 
class getItemForSource_args:
13684 
  """
13685 
  Attributes:
13686 
   - item_id
13687 
   - sourceId
13688 
  """
13689 
 
13690 
  thrift_spec = (
13691 
    None, # 0
13692 
    (1, TType.I64, 'item_id', None, None, ), # 1
13693 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13694 
  )
13695 
 
13696 
  def __init__(self, item_id=None, sourceId=None,):
13697 
    self.item_id = item_id
13698 
    self.sourceId = sourceId
13699 
 
13700 
  def read(self, iprot):
13701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13703 
      return
13704 
    iprot.readStructBegin()
13705 
    while True:
13706 
      (fname, ftype, fid) = iprot.readFieldBegin()
13707 
      if ftype == TType.STOP:
13708 
        break
13709 
      if fid == 1:
13710 
        if ftype == TType.I64:
13711 
          self.item_id = iprot.readI64();
13712 
        else:
13713 
          iprot.skip(ftype)
13714 
      elif fid == 2:
13715 
        if ftype == TType.I64:
13716 
          self.sourceId = iprot.readI64();
13717 
        else:
13718 
          iprot.skip(ftype)
13719 
      else:
13720 
        iprot.skip(ftype)
13721 
      iprot.readFieldEnd()
13722 
    iprot.readStructEnd()
13723 
 
13724 
  def write(self, oprot):
13725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13727 
      return
13728 
    oprot.writeStructBegin('getItemForSource_args')
13729 
    if self.item_id is not None:
13730 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13731 
      oprot.writeI64(self.item_id)
13732 
      oprot.writeFieldEnd()
13733 
    if self.sourceId is not None:
13734 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13735 
      oprot.writeI64(self.sourceId)
13736 
      oprot.writeFieldEnd()
13737 
    oprot.writeFieldStop()
13738 
    oprot.writeStructEnd()
13739 
 
13740 
  def validate(self):
13741 
    return
13742 
 
13743 
 
13744 
  def __repr__(self):
13745 
    L = ['%s=%r' % (key, value)
13746 
      for key, value in self.__dict__.iteritems()]
13747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13748 
 
13749 
  def __eq__(self, other):
13750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13751 
 
13752 
  def __ne__(self, other):
13753 
    return not (self == other)
13754 
 
13755 
class getItemForSource_result:
13756 
  """
13757 
  Attributes:
13758 
   - success
13759 
   - cex
13760 
  """
13761 
 
13762 
  thrift_spec = (
13763 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13764 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13765 
  )
13766 
 
13767 
  def __init__(self, success=None, cex=None,):
13768 
    self.success = success
13769 
    self.cex = cex
13770 
 
13771 
  def read(self, iprot):
13772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13774 
      return
13775 
    iprot.readStructBegin()
13776 
    while True:
13777 
      (fname, ftype, fid) = iprot.readFieldBegin()
13778 
      if ftype == TType.STOP:
13779 
        break
13780 
      if fid == 0:
13781 
        if ftype == TType.STRUCT:
13782 
          self.success = Item()
13783 
          self.success.read(iprot)
13784 
        else:
13785 
          iprot.skip(ftype)
13786 
      elif fid == 1:
13787 
        if ftype == TType.STRUCT:
13788 
          self.cex = CatalogServiceException()
13789 
          self.cex.read(iprot)
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('getItemForSource_result')
13802 
    if self.success is not None:
13803 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13804 
      self.success.write(oprot)
13805 
      oprot.writeFieldEnd()
13806 
    if self.cex is not None:
13807 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13808 
      self.cex.write(oprot)
13809 
      oprot.writeFieldEnd()
13810 
    oprot.writeFieldStop()
13811 
    oprot.writeStructEnd()
13812 
 
13813 
  def validate(self):
13814 
    return
13815 
 
13816 
 
13817 
  def __repr__(self):
13818 
    L = ['%s=%r' % (key, value)
13819 
      for key, value in self.__dict__.iteritems()]
13820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13821 
 
13822 
  def __eq__(self, other):
13823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13824 
 
13825 
  def __ne__(self, other):
13826 
    return not (self == other)
13827 
 
13828 
class searchItemsInRange_args:
13829 
  """
13830 
  Attributes:
13831 
   - searchTerms
13832 
   - offset
13833 
   - limit
13834 
  """
13835 
 
13836 
  thrift_spec = (
13837 
    None, # 0
13838 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13839 
    (2, TType.I64, 'offset', None, None, ), # 2
13840 
    (3, TType.I64, 'limit', None, None, ), # 3
13841 
  )
13842 
 
13843 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13844 
    self.searchTerms = searchTerms
13845 
    self.offset = offset
13846 
    self.limit = limit
13847 
 
13848 
  def read(self, iprot):
13849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13851 
      return
13852 
    iprot.readStructBegin()
13853 
    while True:
13854 
      (fname, ftype, fid) = iprot.readFieldBegin()
13855 
      if ftype == TType.STOP:
13856 
        break
13857 
      if fid == 1:
13858 
        if ftype == TType.LIST:
13859 
          self.searchTerms = []
7438 amit.gupta 13860 
          (_etype254, _size251) = iprot.readListBegin()
13861 
          for _i255 in xrange(_size251):
13862 
            _elem256 = iprot.readString();
13863 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 13864 
          iprot.readListEnd()
13865 
        else:
13866 
          iprot.skip(ftype)
13867 
      elif fid == 2:
13868 
        if ftype == TType.I64:
13869 
          self.offset = iprot.readI64();
13870 
        else:
13871 
          iprot.skip(ftype)
13872 
      elif fid == 3:
13873 
        if ftype == TType.I64:
13874 
          self.limit = iprot.readI64();
13875 
        else:
13876 
          iprot.skip(ftype)
13877 
      else:
13878 
        iprot.skip(ftype)
13879 
      iprot.readFieldEnd()
13880 
    iprot.readStructEnd()
13881 
 
13882 
  def write(self, oprot):
13883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13885 
      return
13886 
    oprot.writeStructBegin('searchItemsInRange_args')
13887 
    if self.searchTerms is not None:
13888 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13889 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 13890 
      for iter257 in self.searchTerms:
13891 
        oprot.writeString(iter257)
5944 mandeep.dh 13892 
      oprot.writeListEnd()
13893 
      oprot.writeFieldEnd()
13894 
    if self.offset is not None:
13895 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13896 
      oprot.writeI64(self.offset)
13897 
      oprot.writeFieldEnd()
13898 
    if self.limit is not None:
13899 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13900 
      oprot.writeI64(self.limit)
13901 
      oprot.writeFieldEnd()
13902 
    oprot.writeFieldStop()
13903 
    oprot.writeStructEnd()
13904 
 
13905 
  def validate(self):
13906 
    return
13907 
 
13908 
 
13909 
  def __repr__(self):
13910 
    L = ['%s=%r' % (key, value)
13911 
      for key, value in self.__dict__.iteritems()]
13912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13913 
 
13914 
  def __eq__(self, other):
13915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13916 
 
13917 
  def __ne__(self, other):
13918 
    return not (self == other)
13919 
 
13920 
class searchItemsInRange_result:
13921 
  """
13922 
  Attributes:
13923 
   - success
13924 
  """
13925 
 
13926 
  thrift_spec = (
13927 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13928 
  )
13929 
 
13930 
  def __init__(self, success=None,):
13931 
    self.success = success
13932 
 
13933 
  def read(self, iprot):
13934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13936 
      return
13937 
    iprot.readStructBegin()
13938 
    while True:
13939 
      (fname, ftype, fid) = iprot.readFieldBegin()
13940 
      if ftype == TType.STOP:
13941 
        break
13942 
      if fid == 0:
13943 
        if ftype == TType.LIST:
13944 
          self.success = []
7438 amit.gupta 13945 
          (_etype261, _size258) = iprot.readListBegin()
13946 
          for _i262 in xrange(_size258):
13947 
            _elem263 = Item()
13948 
            _elem263.read(iprot)
13949 
            self.success.append(_elem263)
5944 mandeep.dh 13950 
          iprot.readListEnd()
13951 
        else:
13952 
          iprot.skip(ftype)
13953 
      else:
13954 
        iprot.skip(ftype)
13955 
      iprot.readFieldEnd()
13956 
    iprot.readStructEnd()
13957 
 
13958 
  def write(self, oprot):
13959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13961 
      return
13962 
    oprot.writeStructBegin('searchItemsInRange_result')
13963 
    if self.success is not None:
13964 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13965 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13966 
      for iter264 in self.success:
13967 
        iter264.write(oprot)
5944 mandeep.dh 13968 
      oprot.writeListEnd()
13969 
      oprot.writeFieldEnd()
13970 
    oprot.writeFieldStop()
13971 
    oprot.writeStructEnd()
13972 
 
13973 
  def validate(self):
13974 
    return
13975 
 
13976 
 
13977 
  def __repr__(self):
13978 
    L = ['%s=%r' % (key, value)
13979 
      for key, value in self.__dict__.iteritems()]
13980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13981 
 
13982 
  def __eq__(self, other):
13983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13984 
 
13985 
  def __ne__(self, other):
13986 
    return not (self == other)
13987 
 
13988 
class getSearchResultCount_args:
13989 
  """
13990 
  Attributes:
13991 
   - searchTerms
13992 
  """
13993 
 
13994 
  thrift_spec = (
13995 
    None, # 0
13996 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13997 
  )
13998 
 
13999 
  def __init__(self, searchTerms=None,):
14000 
    self.searchTerms = searchTerms
14001 
 
14002 
  def read(self, iprot):
14003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14005 
      return
14006 
    iprot.readStructBegin()
14007 
    while True:
14008 
      (fname, ftype, fid) = iprot.readFieldBegin()
14009 
      if ftype == TType.STOP:
14010 
        break
14011 
      if fid == 1:
14012 
        if ftype == TType.LIST:
14013 
          self.searchTerms = []
7438 amit.gupta 14014 
          (_etype268, _size265) = iprot.readListBegin()
14015 
          for _i269 in xrange(_size265):
14016 
            _elem270 = iprot.readString();
14017 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14018 
          iprot.readListEnd()
14019 
        else:
14020 
          iprot.skip(ftype)
14021 
      else:
14022 
        iprot.skip(ftype)
14023 
      iprot.readFieldEnd()
14024 
    iprot.readStructEnd()
14025 
 
14026 
  def write(self, oprot):
14027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14029 
      return
14030 
    oprot.writeStructBegin('getSearchResultCount_args')
14031 
    if self.searchTerms is not None:
14032 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14033 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14034 
      for iter271 in self.searchTerms:
14035 
        oprot.writeString(iter271)
5944 mandeep.dh 14036 
      oprot.writeListEnd()
14037 
      oprot.writeFieldEnd()
14038 
    oprot.writeFieldStop()
14039 
    oprot.writeStructEnd()
14040 
 
14041 
  def validate(self):
14042 
    return
14043 
 
14044 
 
14045 
  def __repr__(self):
14046 
    L = ['%s=%r' % (key, value)
14047 
      for key, value in self.__dict__.iteritems()]
14048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14049 
 
14050 
  def __eq__(self, other):
14051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14052 
 
14053 
  def __ne__(self, other):
14054 
    return not (self == other)
14055 
 
14056 
class getSearchResultCount_result:
14057 
  """
14058 
  Attributes:
14059 
   - success
14060 
  """
14061 
 
14062 
  thrift_spec = (
14063 
    (0, TType.I32, 'success', None, None, ), # 0
14064 
  )
14065 
 
14066 
  def __init__(self, success=None,):
14067 
    self.success = success
14068 
 
14069 
  def read(self, iprot):
14070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14072 
      return
14073 
    iprot.readStructBegin()
14074 
    while True:
14075 
      (fname, ftype, fid) = iprot.readFieldBegin()
14076 
      if ftype == TType.STOP:
14077 
        break
14078 
      if fid == 0:
14079 
        if ftype == TType.I32:
14080 
          self.success = iprot.readI32();
14081 
        else:
14082 
          iprot.skip(ftype)
14083 
      else:
14084 
        iprot.skip(ftype)
14085 
      iprot.readFieldEnd()
14086 
    iprot.readStructEnd()
14087 
 
14088 
  def write(self, oprot):
14089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14091 
      return
14092 
    oprot.writeStructBegin('getSearchResultCount_result')
14093 
    if self.success is not None:
14094 
      oprot.writeFieldBegin('success', TType.I32, 0)
14095 
      oprot.writeI32(self.success)
14096 
      oprot.writeFieldEnd()
14097 
    oprot.writeFieldStop()
14098 
    oprot.writeStructEnd()
14099 
 
14100 
  def validate(self):
14101 
    return
14102 
 
14103 
 
14104 
  def __repr__(self):
14105 
    L = ['%s=%r' % (key, value)
14106 
      for key, value in self.__dict__.iteritems()]
14107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14108 
 
14109 
  def __eq__(self, other):
14110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14111 
 
14112 
  def __ne__(self, other):
14113 
    return not (self == other)
14114 
 
14115 
class getProductNotifications_args:
14116 
  """
14117 
  Attributes:
14118 
   - startDateTime
14119 
  """
14120 
 
14121 
  thrift_spec = (
14122 
    None, # 0
14123 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14124 
  )
14125 
 
14126 
  def __init__(self, startDateTime=None,):
14127 
    self.startDateTime = startDateTime
14128 
 
14129 
  def read(self, iprot):
14130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14132 
      return
14133 
    iprot.readStructBegin()
14134 
    while True:
14135 
      (fname, ftype, fid) = iprot.readFieldBegin()
14136 
      if ftype == TType.STOP:
14137 
        break
14138 
      if fid == 1:
14139 
        if ftype == TType.I64:
14140 
          self.startDateTime = iprot.readI64();
14141 
        else:
14142 
          iprot.skip(ftype)
14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
14152 
    oprot.writeStructBegin('getProductNotifications_args')
14153 
    if self.startDateTime is not None:
14154 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14155 
      oprot.writeI64(self.startDateTime)
14156 
      oprot.writeFieldEnd()
14157 
    oprot.writeFieldStop()
14158 
    oprot.writeStructEnd()
14159 
 
14160 
  def validate(self):
14161 
    return
14162 
 
14163 
 
14164 
  def __repr__(self):
14165 
    L = ['%s=%r' % (key, value)
14166 
      for key, value in self.__dict__.iteritems()]
14167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14168 
 
14169 
  def __eq__(self, other):
14170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14171 
 
14172 
  def __ne__(self, other):
14173 
    return not (self == other)
14174 
 
14175 
class getProductNotifications_result:
14176 
  """
14177 
  Attributes:
14178 
   - success
14179 
  """
14180 
 
14181 
  thrift_spec = (
14182 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14183 
  )
14184 
 
14185 
  def __init__(self, success=None,):
14186 
    self.success = success
14187 
 
14188 
  def read(self, iprot):
14189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14191 
      return
14192 
    iprot.readStructBegin()
14193 
    while True:
14194 
      (fname, ftype, fid) = iprot.readFieldBegin()
14195 
      if ftype == TType.STOP:
14196 
        break
14197 
      if fid == 0:
14198 
        if ftype == TType.LIST:
14199 
          self.success = []
7438 amit.gupta 14200 
          (_etype275, _size272) = iprot.readListBegin()
14201 
          for _i276 in xrange(_size272):
14202 
            _elem277 = ProductNotificationRequest()
14203 
            _elem277.read(iprot)
14204 
            self.success.append(_elem277)
5944 mandeep.dh 14205 
          iprot.readListEnd()
14206 
        else:
14207 
          iprot.skip(ftype)
14208 
      else:
14209 
        iprot.skip(ftype)
14210 
      iprot.readFieldEnd()
14211 
    iprot.readStructEnd()
14212 
 
14213 
  def write(self, oprot):
14214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14216 
      return
14217 
    oprot.writeStructBegin('getProductNotifications_result')
14218 
    if self.success is not None:
14219 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14220 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14221 
      for iter278 in self.success:
14222 
        iter278.write(oprot)
5944 mandeep.dh 14223 
      oprot.writeListEnd()
14224 
      oprot.writeFieldEnd()
14225 
    oprot.writeFieldStop()
14226 
    oprot.writeStructEnd()
14227 
 
14228 
  def validate(self):
14229 
    return
14230 
 
14231 
 
14232 
  def __repr__(self):
14233 
    L = ['%s=%r' % (key, value)
14234 
      for key, value in self.__dict__.iteritems()]
14235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14236 
 
14237 
  def __eq__(self, other):
14238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14239 
 
14240 
  def __ne__(self, other):
14241 
    return not (self == other)
14242 
 
14243 
class getProductNotificationRequestCount_args:
14244 
  """
14245 
  Attributes:
14246 
   - startDateTime
14247 
  """
14248 
 
14249 
  thrift_spec = (
14250 
    None, # 0
14251 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14252 
  )
14253 
 
14254 
  def __init__(self, startDateTime=None,):
14255 
    self.startDateTime = startDateTime
14256 
 
14257 
  def read(self, iprot):
14258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14260 
      return
14261 
    iprot.readStructBegin()
14262 
    while True:
14263 
      (fname, ftype, fid) = iprot.readFieldBegin()
14264 
      if ftype == TType.STOP:
14265 
        break
14266 
      if fid == 1:
14267 
        if ftype == TType.I64:
14268 
          self.startDateTime = iprot.readI64();
14269 
        else:
14270 
          iprot.skip(ftype)
14271 
      else:
14272 
        iprot.skip(ftype)
14273 
      iprot.readFieldEnd()
14274 
    iprot.readStructEnd()
14275 
 
14276 
  def write(self, oprot):
14277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14279 
      return
14280 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14281 
    if self.startDateTime is not None:
14282 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14283 
      oprot.writeI64(self.startDateTime)
14284 
      oprot.writeFieldEnd()
14285 
    oprot.writeFieldStop()
14286 
    oprot.writeStructEnd()
14287 
 
14288 
  def validate(self):
14289 
    return
14290 
 
14291 
 
14292 
  def __repr__(self):
14293 
    L = ['%s=%r' % (key, value)
14294 
      for key, value in self.__dict__.iteritems()]
14295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14296 
 
14297 
  def __eq__(self, other):
14298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14299 
 
14300 
  def __ne__(self, other):
14301 
    return not (self == other)
14302 
 
14303 
class getProductNotificationRequestCount_result:
14304 
  """
14305 
  Attributes:
14306 
   - success
14307 
  """
14308 
 
14309 
  thrift_spec = (
14310 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14311 
  )
14312 
 
14313 
  def __init__(self, success=None,):
14314 
    self.success = success
14315 
 
14316 
  def read(self, iprot):
14317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14319 
      return
14320 
    iprot.readStructBegin()
14321 
    while True:
14322 
      (fname, ftype, fid) = iprot.readFieldBegin()
14323 
      if ftype == TType.STOP:
14324 
        break
14325 
      if fid == 0:
14326 
        if ftype == TType.LIST:
14327 
          self.success = []
7438 amit.gupta 14328 
          (_etype282, _size279) = iprot.readListBegin()
14329 
          for _i283 in xrange(_size279):
14330 
            _elem284 = ProductNotificationRequestCount()
14331 
            _elem284.read(iprot)
14332 
            self.success.append(_elem284)
5944 mandeep.dh 14333 
          iprot.readListEnd()
14334 
        else:
14335 
          iprot.skip(ftype)
14336 
      else:
14337 
        iprot.skip(ftype)
14338 
      iprot.readFieldEnd()
14339 
    iprot.readStructEnd()
14340 
 
14341 
  def write(self, oprot):
14342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14344 
      return
14345 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14346 
    if self.success is not None:
14347 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14348 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14349 
      for iter285 in self.success:
14350 
        iter285.write(oprot)
5944 mandeep.dh 14351 
      oprot.writeListEnd()
14352 
      oprot.writeFieldEnd()
14353 
    oprot.writeFieldStop()
14354 
    oprot.writeStructEnd()
14355 
 
14356 
  def validate(self):
14357 
    return
14358 
 
14359 
 
14360 
  def __repr__(self):
14361 
    L = ['%s=%r' % (key, value)
14362 
      for key, value in self.__dict__.iteritems()]
14363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14364 
 
14365 
  def __eq__(self, other):
14366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14367 
 
14368 
  def __ne__(self, other):
14369 
    return not (self == other)
14370 
 
14371 
class addAuthorizationLog_args:
14372 
  """
14373 
  Attributes:
14374 
   - itemId
14375 
   - username
14376 
   - reason
14377 
  """
14378 
 
14379 
  thrift_spec = (
14380 
    None, # 0
14381 
    (1, TType.I64, 'itemId', None, None, ), # 1
14382 
    (2, TType.STRING, 'username', None, None, ), # 2
14383 
    (3, TType.STRING, 'reason', None, None, ), # 3
14384 
  )
14385 
 
14386 
  def __init__(self, itemId=None, username=None, reason=None,):
14387 
    self.itemId = itemId
14388 
    self.username = username
14389 
    self.reason = reason
14390 
 
14391 
  def read(self, iprot):
14392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14394 
      return
14395 
    iprot.readStructBegin()
14396 
    while True:
14397 
      (fname, ftype, fid) = iprot.readFieldBegin()
14398 
      if ftype == TType.STOP:
14399 
        break
14400 
      if fid == 1:
14401 
        if ftype == TType.I64:
14402 
          self.itemId = iprot.readI64();
14403 
        else:
14404 
          iprot.skip(ftype)
14405 
      elif fid == 2:
14406 
        if ftype == TType.STRING:
14407 
          self.username = iprot.readString();
14408 
        else:
14409 
          iprot.skip(ftype)
14410 
      elif fid == 3:
14411 
        if ftype == TType.STRING:
14412 
          self.reason = iprot.readString();
14413 
        else:
14414 
          iprot.skip(ftype)
14415 
      else:
14416 
        iprot.skip(ftype)
14417 
      iprot.readFieldEnd()
14418 
    iprot.readStructEnd()
14419 
 
14420 
  def write(self, oprot):
14421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14423 
      return
14424 
    oprot.writeStructBegin('addAuthorizationLog_args')
14425 
    if self.itemId is not None:
14426 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14427 
      oprot.writeI64(self.itemId)
14428 
      oprot.writeFieldEnd()
14429 
    if self.username is not None:
14430 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14431 
      oprot.writeString(self.username)
14432 
      oprot.writeFieldEnd()
14433 
    if self.reason is not None:
14434 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14435 
      oprot.writeString(self.reason)
14436 
      oprot.writeFieldEnd()
14437 
    oprot.writeFieldStop()
14438 
    oprot.writeStructEnd()
14439 
 
14440 
  def validate(self):
14441 
    return
14442 
 
14443 
 
14444 
  def __repr__(self):
14445 
    L = ['%s=%r' % (key, value)
14446 
      for key, value in self.__dict__.iteritems()]
14447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14448 
 
14449 
  def __eq__(self, other):
14450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14451 
 
14452 
  def __ne__(self, other):
14453 
    return not (self == other)
14454 
 
14455 
class addAuthorizationLog_result:
14456 
  """
14457 
  Attributes:
14458 
   - success
14459 
   - cex
14460 
  """
14461 
 
14462 
  thrift_spec = (
14463 
    (0, TType.BOOL, 'success', None, None, ), # 0
14464 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14465 
  )
14466 
 
14467 
  def __init__(self, success=None, cex=None,):
14468 
    self.success = success
14469 
    self.cex = cex
14470 
 
14471 
  def read(self, iprot):
14472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14474 
      return
14475 
    iprot.readStructBegin()
14476 
    while True:
14477 
      (fname, ftype, fid) = iprot.readFieldBegin()
14478 
      if ftype == TType.STOP:
14479 
        break
14480 
      if fid == 0:
14481 
        if ftype == TType.BOOL:
14482 
          self.success = iprot.readBool();
14483 
        else:
14484 
          iprot.skip(ftype)
14485 
      elif fid == 1:
14486 
        if ftype == TType.STRUCT:
14487 
          self.cex = CatalogServiceException()
14488 
          self.cex.read(iprot)
14489 
        else:
14490 
          iprot.skip(ftype)
14491 
      else:
14492 
        iprot.skip(ftype)
14493 
      iprot.readFieldEnd()
14494 
    iprot.readStructEnd()
14495 
 
14496 
  def write(self, oprot):
14497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14499 
      return
14500 
    oprot.writeStructBegin('addAuthorizationLog_result')
14501 
    if self.success is not None:
14502 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14503 
      oprot.writeBool(self.success)
14504 
      oprot.writeFieldEnd()
14505 
    if self.cex is not None:
14506 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14507 
      self.cex.write(oprot)
14508 
      oprot.writeFieldEnd()
14509 
    oprot.writeFieldStop()
14510 
    oprot.writeStructEnd()
14511 
 
14512 
  def validate(self):
14513 
    return
14514 
 
14515 
 
14516 
  def __repr__(self):
14517 
    L = ['%s=%r' % (key, value)
14518 
      for key, value in self.__dict__.iteritems()]
14519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14520 
 
14521 
  def __eq__(self, other):
14522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14523 
 
14524 
  def __ne__(self, other):
14525 
    return not (self == other)
14526 
 
14527 
class addupdateVoucherForItem_args:
14528 
  """
14529 
  Attributes:
14530 
   - catalog_item_id
14531 
   - voucherType
14532 
   - voucherAmount
14533 
  """
14534 
 
14535 
  thrift_spec = (
14536 
    None, # 0
14537 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14538 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14539 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14540 
  )
14541 
 
14542 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14543 
    self.catalog_item_id = catalog_item_id
14544 
    self.voucherType = voucherType
14545 
    self.voucherAmount = voucherAmount
14546 
 
14547 
  def read(self, iprot):
14548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14550 
      return
14551 
    iprot.readStructBegin()
14552 
    while True:
14553 
      (fname, ftype, fid) = iprot.readFieldBegin()
14554 
      if ftype == TType.STOP:
14555 
        break
14556 
      if fid == 1:
14557 
        if ftype == TType.I64:
14558 
          self.catalog_item_id = iprot.readI64();
14559 
        else:
14560 
          iprot.skip(ftype)
14561 
      elif fid == 2:
14562 
        if ftype == TType.I64:
14563 
          self.voucherType = iprot.readI64();
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      elif fid == 3:
14567 
        if ftype == TType.I64:
14568 
          self.voucherAmount = iprot.readI64();
14569 
        else:
14570 
          iprot.skip(ftype)
14571 
      else:
14572 
        iprot.skip(ftype)
14573 
      iprot.readFieldEnd()
14574 
    iprot.readStructEnd()
14575 
 
14576 
  def write(self, oprot):
14577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14579 
      return
14580 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14581 
    if self.catalog_item_id is not None:
14582 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14583 
      oprot.writeI64(self.catalog_item_id)
14584 
      oprot.writeFieldEnd()
14585 
    if self.voucherType is not None:
14586 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14587 
      oprot.writeI64(self.voucherType)
14588 
      oprot.writeFieldEnd()
14589 
    if self.voucherAmount is not None:
14590 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14591 
      oprot.writeI64(self.voucherAmount)
14592 
      oprot.writeFieldEnd()
14593 
    oprot.writeFieldStop()
14594 
    oprot.writeStructEnd()
14595 
 
14596 
  def validate(self):
14597 
    return
14598 
 
14599 
 
14600 
  def __repr__(self):
14601 
    L = ['%s=%r' % (key, value)
14602 
      for key, value in self.__dict__.iteritems()]
14603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14604 
 
14605 
  def __eq__(self, other):
14606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14607 
 
14608 
  def __ne__(self, other):
14609 
    return not (self == other)
14610 
 
14611 
class addupdateVoucherForItem_result:
14612 
  """
14613 
  Attributes:
14614 
   - success
14615 
   - cex
14616 
  """
14617 
 
14618 
  thrift_spec = (
14619 
    (0, TType.BOOL, 'success', None, None, ), # 0
14620 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14621 
  )
14622 
 
14623 
  def __init__(self, success=None, cex=None,):
14624 
    self.success = success
14625 
    self.cex = cex
14626 
 
14627 
  def read(self, iprot):
14628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14630 
      return
14631 
    iprot.readStructBegin()
14632 
    while True:
14633 
      (fname, ftype, fid) = iprot.readFieldBegin()
14634 
      if ftype == TType.STOP:
14635 
        break
14636 
      if fid == 0:
14637 
        if ftype == TType.BOOL:
14638 
          self.success = iprot.readBool();
14639 
        else:
14640 
          iprot.skip(ftype)
14641 
      elif fid == 1:
14642 
        if ftype == TType.STRUCT:
14643 
          self.cex = CatalogServiceException()
14644 
          self.cex.read(iprot)
14645 
        else:
14646 
          iprot.skip(ftype)
14647 
      else:
14648 
        iprot.skip(ftype)
14649 
      iprot.readFieldEnd()
14650 
    iprot.readStructEnd()
14651 
 
14652 
  def write(self, oprot):
14653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14655 
      return
14656 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14657 
    if self.success is not None:
14658 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14659 
      oprot.writeBool(self.success)
14660 
      oprot.writeFieldEnd()
14661 
    if self.cex is not None:
14662 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14663 
      self.cex.write(oprot)
14664 
      oprot.writeFieldEnd()
14665 
    oprot.writeFieldStop()
14666 
    oprot.writeStructEnd()
14667 
 
14668 
  def validate(self):
14669 
    return
14670 
 
14671 
 
14672 
  def __repr__(self):
14673 
    L = ['%s=%r' % (key, value)
14674 
      for key, value in self.__dict__.iteritems()]
14675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14676 
 
14677 
  def __eq__(self, other):
14678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14679 
 
14680 
  def __ne__(self, other):
14681 
    return not (self == other)
14682 
 
14683 
class deleteVoucherForItem_args:
14684 
  """
14685 
  Attributes:
14686 
   - catalog_item_id
14687 
   - voucherType
14688 
  """
14689 
 
14690 
  thrift_spec = (
14691 
    None, # 0
14692 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14693 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14694 
  )
14695 
 
14696 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14697 
    self.catalog_item_id = catalog_item_id
14698 
    self.voucherType = voucherType
14699 
 
14700 
  def read(self, iprot):
14701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14703 
      return
14704 
    iprot.readStructBegin()
14705 
    while True:
14706 
      (fname, ftype, fid) = iprot.readFieldBegin()
14707 
      if ftype == TType.STOP:
14708 
        break
14709 
      if fid == 1:
14710 
        if ftype == TType.I64:
14711 
          self.catalog_item_id = iprot.readI64();
14712 
        else:
14713 
          iprot.skip(ftype)
14714 
      elif fid == 2:
14715 
        if ftype == TType.I64:
14716 
          self.voucherType = iprot.readI64();
14717 
        else:
14718 
          iprot.skip(ftype)
14719 
      else:
14720 
        iprot.skip(ftype)
14721 
      iprot.readFieldEnd()
14722 
    iprot.readStructEnd()
14723 
 
14724 
  def write(self, oprot):
14725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14727 
      return
14728 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14729 
    if self.catalog_item_id is not None:
14730 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14731 
      oprot.writeI64(self.catalog_item_id)
14732 
      oprot.writeFieldEnd()
14733 
    if self.voucherType is not None:
14734 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14735 
      oprot.writeI64(self.voucherType)
14736 
      oprot.writeFieldEnd()
14737 
    oprot.writeFieldStop()
14738 
    oprot.writeStructEnd()
14739 
 
14740 
  def validate(self):
14741 
    return
14742 
 
14743 
 
14744 
  def __repr__(self):
14745 
    L = ['%s=%r' % (key, value)
14746 
      for key, value in self.__dict__.iteritems()]
14747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14748 
 
14749 
  def __eq__(self, other):
14750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14751 
 
14752 
  def __ne__(self, other):
14753 
    return not (self == other)
14754 
 
14755 
class deleteVoucherForItem_result:
14756 
  """
14757 
  Attributes:
14758 
   - success
14759 
   - cex
14760 
  """
14761 
 
14762 
  thrift_spec = (
14763 
    (0, TType.BOOL, 'success', None, None, ), # 0
14764 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14765 
  )
14766 
 
14767 
  def __init__(self, success=None, cex=None,):
14768 
    self.success = success
14769 
    self.cex = cex
14770 
 
14771 
  def read(self, iprot):
14772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14774 
      return
14775 
    iprot.readStructBegin()
14776 
    while True:
14777 
      (fname, ftype, fid) = iprot.readFieldBegin()
14778 
      if ftype == TType.STOP:
14779 
        break
14780 
      if fid == 0:
14781 
        if ftype == TType.BOOL:
14782 
          self.success = iprot.readBool();
14783 
        else:
14784 
          iprot.skip(ftype)
14785 
      elif fid == 1:
14786 
        if ftype == TType.STRUCT:
14787 
          self.cex = CatalogServiceException()
14788 
          self.cex.read(iprot)
14789 
        else:
14790 
          iprot.skip(ftype)
14791 
      else:
14792 
        iprot.skip(ftype)
14793 
      iprot.readFieldEnd()
14794 
    iprot.readStructEnd()
14795 
 
14796 
  def write(self, oprot):
14797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14799 
      return
14800 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14801 
    if self.success is not None:
14802 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14803 
      oprot.writeBool(self.success)
14804 
      oprot.writeFieldEnd()
14805 
    if self.cex is not None:
14806 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14807 
      self.cex.write(oprot)
14808 
      oprot.writeFieldEnd()
14809 
    oprot.writeFieldStop()
14810 
    oprot.writeStructEnd()
14811 
 
14812 
  def validate(self):
14813 
    return
14814 
 
14815 
 
14816 
  def __repr__(self):
14817 
    L = ['%s=%r' % (key, value)
14818 
      for key, value in self.__dict__.iteritems()]
14819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14820 
 
14821 
  def __eq__(self, other):
14822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14823 
 
14824 
  def __ne__(self, other):
14825 
    return not (self == other)
14826 
 
14827 
class getVoucherAmount_args:
14828 
  """
14829 
  Attributes:
14830 
   - itemId
14831 
   - voucherType
14832 
  """
14833 
 
14834 
  thrift_spec = (
14835 
    None, # 0
14836 
    (1, TType.I64, 'itemId', None, None, ), # 1
14837 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14838 
  )
14839 
 
14840 
  def __init__(self, itemId=None, voucherType=None,):
14841 
    self.itemId = itemId
14842 
    self.voucherType = voucherType
14843 
 
14844 
  def read(self, iprot):
14845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14847 
      return
14848 
    iprot.readStructBegin()
14849 
    while True:
14850 
      (fname, ftype, fid) = iprot.readFieldBegin()
14851 
      if ftype == TType.STOP:
14852 
        break
14853 
      if fid == 1:
14854 
        if ftype == TType.I64:
14855 
          self.itemId = iprot.readI64();
14856 
        else:
14857 
          iprot.skip(ftype)
14858 
      elif fid == 2:
14859 
        if ftype == TType.I64:
14860 
          self.voucherType = iprot.readI64();
14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
14872 
    oprot.writeStructBegin('getVoucherAmount_args')
14873 
    if self.itemId is not None:
14874 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14875 
      oprot.writeI64(self.itemId)
14876 
      oprot.writeFieldEnd()
14877 
    if self.voucherType is not None:
14878 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14879 
      oprot.writeI64(self.voucherType)
14880 
      oprot.writeFieldEnd()
14881 
    oprot.writeFieldStop()
14882 
    oprot.writeStructEnd()
14883 
 
14884 
  def validate(self):
14885 
    return
14886 
 
14887 
 
14888 
  def __repr__(self):
14889 
    L = ['%s=%r' % (key, value)
14890 
      for key, value in self.__dict__.iteritems()]
14891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14892 
 
14893 
  def __eq__(self, other):
14894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14895 
 
14896 
  def __ne__(self, other):
14897 
    return not (self == other)
14898 
 
14899 
class getVoucherAmount_result:
14900 
  """
14901 
  Attributes:
14902 
   - success
14903 
  """
14904 
 
14905 
  thrift_spec = (
14906 
    (0, TType.I64, 'success', None, None, ), # 0
14907 
  )
14908 
 
14909 
  def __init__(self, success=None,):
14910 
    self.success = success
14911 
 
14912 
  def read(self, iprot):
14913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14915 
      return
14916 
    iprot.readStructBegin()
14917 
    while True:
14918 
      (fname, ftype, fid) = iprot.readFieldBegin()
14919 
      if ftype == TType.STOP:
14920 
        break
14921 
      if fid == 0:
14922 
        if ftype == TType.I64:
14923 
          self.success = iprot.readI64();
14924 
        else:
14925 
          iprot.skip(ftype)
14926 
      else:
14927 
        iprot.skip(ftype)
14928 
      iprot.readFieldEnd()
14929 
    iprot.readStructEnd()
14930 
 
14931 
  def write(self, oprot):
14932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14934 
      return
14935 
    oprot.writeStructBegin('getVoucherAmount_result')
14936 
    if self.success is not None:
14937 
      oprot.writeFieldBegin('success', TType.I64, 0)
14938 
      oprot.writeI64(self.success)
14939 
      oprot.writeFieldEnd()
14940 
    oprot.writeFieldStop()
14941 
    oprot.writeStructEnd()
14942 
 
14943 
  def validate(self):
14944 
    return
14945 
 
14946 
 
14947 
  def __repr__(self):
14948 
    L = ['%s=%r' % (key, value)
14949 
      for key, value in self.__dict__.iteritems()]
14950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14951 
 
14952 
  def __eq__(self, other):
14953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14954 
 
14955 
  def __ne__(self, other):
14956 
    return not (self == other)
14957 
 
14958 
class getAllItemVouchers_args:
14959 
  """
14960 
  Attributes:
14961 
   - itemId
14962 
  """
14963 
 
14964 
  thrift_spec = (
14965 
    None, # 0
14966 
    (1, TType.I64, 'itemId', None, None, ), # 1
14967 
  )
14968 
 
14969 
  def __init__(self, itemId=None,):
14970 
    self.itemId = itemId
14971 
 
14972 
  def read(self, iprot):
14973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14975 
      return
14976 
    iprot.readStructBegin()
14977 
    while True:
14978 
      (fname, ftype, fid) = iprot.readFieldBegin()
14979 
      if ftype == TType.STOP:
14980 
        break
14981 
      if fid == 1:
14982 
        if ftype == TType.I64:
14983 
          self.itemId = iprot.readI64();
14984 
        else:
14985 
          iprot.skip(ftype)
14986 
      else:
14987 
        iprot.skip(ftype)
14988 
      iprot.readFieldEnd()
14989 
    iprot.readStructEnd()
14990 
 
14991 
  def write(self, oprot):
14992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14994 
      return
14995 
    oprot.writeStructBegin('getAllItemVouchers_args')
14996 
    if self.itemId is not None:
14997 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14998 
      oprot.writeI64(self.itemId)
14999 
      oprot.writeFieldEnd()
15000 
    oprot.writeFieldStop()
15001 
    oprot.writeStructEnd()
15002 
 
15003 
  def validate(self):
15004 
    return
15005 
 
15006 
 
15007 
  def __repr__(self):
15008 
    L = ['%s=%r' % (key, value)
15009 
      for key, value in self.__dict__.iteritems()]
15010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15011 
 
15012 
  def __eq__(self, other):
15013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15014 
 
15015 
  def __ne__(self, other):
15016 
    return not (self == other)
15017 
 
15018 
class getAllItemVouchers_result:
15019 
  """
15020 
  Attributes:
15021 
   - success
15022 
  """
15023 
 
15024 
  thrift_spec = (
15025 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15026 
  )
15027 
 
15028 
  def __init__(self, success=None,):
15029 
    self.success = success
15030 
 
15031 
  def read(self, iprot):
15032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15034 
      return
15035 
    iprot.readStructBegin()
15036 
    while True:
15037 
      (fname, ftype, fid) = iprot.readFieldBegin()
15038 
      if ftype == TType.STOP:
15039 
        break
15040 
      if fid == 0:
15041 
        if ftype == TType.LIST:
15042 
          self.success = []
7438 amit.gupta 15043 
          (_etype289, _size286) = iprot.readListBegin()
15044 
          for _i290 in xrange(_size286):
15045 
            _elem291 = VoucherItemMapping()
15046 
            _elem291.read(iprot)
15047 
            self.success.append(_elem291)
5944 mandeep.dh 15048 
          iprot.readListEnd()
15049 
        else:
15050 
          iprot.skip(ftype)
15051 
      else:
15052 
        iprot.skip(ftype)
15053 
      iprot.readFieldEnd()
15054 
    iprot.readStructEnd()
15055 
 
15056 
  def write(self, oprot):
15057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15059 
      return
15060 
    oprot.writeStructBegin('getAllItemVouchers_result')
15061 
    if self.success is not None:
15062 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15063 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15064 
      for iter292 in self.success:
15065 
        iter292.write(oprot)
5944 mandeep.dh 15066 
      oprot.writeListEnd()
15067 
      oprot.writeFieldEnd()
15068 
    oprot.writeFieldStop()
15069 
    oprot.writeStructEnd()
15070 
 
15071 
  def validate(self):
15072 
    return
15073 
 
15074 
 
15075 
  def __repr__(self):
15076 
    L = ['%s=%r' % (key, value)
15077 
      for key, value in self.__dict__.iteritems()]
15078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15079 
 
15080 
  def __eq__(self, other):
15081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15082 
 
15083 
  def __ne__(self, other):
15084 
    return not (self == other)
15085 
 
15086 
class isValidCatalogItemId_args:
15087 
  """
15088 
  Attributes:
15089 
   - catalog_item_id
15090 
  """
15091 
 
15092 
  thrift_spec = (
15093 
    None, # 0
15094 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15095 
  )
15096 
 
15097 
  def __init__(self, catalog_item_id=None,):
15098 
    self.catalog_item_id = catalog_item_id
15099 
 
15100 
  def read(self, iprot):
15101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15103 
      return
15104 
    iprot.readStructBegin()
15105 
    while True:
15106 
      (fname, ftype, fid) = iprot.readFieldBegin()
15107 
      if ftype == TType.STOP:
15108 
        break
15109 
      if fid == 1:
15110 
        if ftype == TType.I64:
15111 
          self.catalog_item_id = iprot.readI64();
15112 
        else:
15113 
          iprot.skip(ftype)
15114 
      else:
15115 
        iprot.skip(ftype)
15116 
      iprot.readFieldEnd()
15117 
    iprot.readStructEnd()
15118 
 
15119 
  def write(self, oprot):
15120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15122 
      return
15123 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15124 
    if self.catalog_item_id is not None:
15125 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15126 
      oprot.writeI64(self.catalog_item_id)
15127 
      oprot.writeFieldEnd()
15128 
    oprot.writeFieldStop()
15129 
    oprot.writeStructEnd()
15130 
 
15131 
  def validate(self):
15132 
    return
15133 
 
15134 
 
15135 
  def __repr__(self):
15136 
    L = ['%s=%r' % (key, value)
15137 
      for key, value in self.__dict__.iteritems()]
15138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15139 
 
15140 
  def __eq__(self, other):
15141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15142 
 
15143 
  def __ne__(self, other):
15144 
    return not (self == other)
15145 
 
15146 
class isValidCatalogItemId_result:
15147 
  """
15148 
  Attributes:
15149 
   - success
15150 
  """
15151 
 
15152 
  thrift_spec = (
15153 
    (0, TType.BOOL, 'success', None, None, ), # 0
15154 
  )
15155 
 
15156 
  def __init__(self, success=None,):
15157 
    self.success = success
15158 
 
15159 
  def read(self, iprot):
15160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15162 
      return
15163 
    iprot.readStructBegin()
15164 
    while True:
15165 
      (fname, ftype, fid) = iprot.readFieldBegin()
15166 
      if ftype == TType.STOP:
15167 
        break
15168 
      if fid == 0:
15169 
        if ftype == TType.BOOL:
15170 
          self.success = iprot.readBool();
15171 
        else:
15172 
          iprot.skip(ftype)
15173 
      else:
15174 
        iprot.skip(ftype)
15175 
      iprot.readFieldEnd()
15176 
    iprot.readStructEnd()
15177 
 
15178 
  def write(self, oprot):
15179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15181 
      return
15182 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15183 
    if self.success is not None:
15184 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15185 
      oprot.writeBool(self.success)
15186 
      oprot.writeFieldEnd()
15187 
    oprot.writeFieldStop()
15188 
    oprot.writeStructEnd()
15189 
 
15190 
  def validate(self):
15191 
    return
15192 
 
15193 
 
15194 
  def __repr__(self):
15195 
    L = ['%s=%r' % (key, value)
15196 
      for key, value in self.__dict__.iteritems()]
15197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15198 
 
15199 
  def __eq__(self, other):
15200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15201 
 
15202 
  def __ne__(self, other):
15203 
    return not (self == other)
6039 amit.gupta 15204 
 
15205 
class getVatPercentageForItem_args:
15206 
  """
15207 
  Attributes:
15208 
   - itemId
7330 amit.gupta 15209 
   - stateId
6039 amit.gupta 15210 
   - price
15211 
  """
15212 
 
15213 
  thrift_spec = (
15214 
    None, # 0
15215 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15216 
    (2, TType.I64, 'stateId', None, None, ), # 2
15217 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15218 
  )
15219 
 
7330 amit.gupta 15220 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15221 
    self.itemId = itemId
7330 amit.gupta 15222 
    self.stateId = stateId
6039 amit.gupta 15223 
    self.price = price
15224 
 
15225 
  def read(self, iprot):
15226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15228 
      return
15229 
    iprot.readStructBegin()
15230 
    while True:
15231 
      (fname, ftype, fid) = iprot.readFieldBegin()
15232 
      if ftype == TType.STOP:
15233 
        break
15234 
      if fid == 1:
15235 
        if ftype == TType.I64:
15236 
          self.itemId = iprot.readI64();
15237 
        else:
15238 
          iprot.skip(ftype)
15239 
      elif fid == 2:
7330 amit.gupta 15240 
        if ftype == TType.I64:
15241 
          self.stateId = iprot.readI64();
15242 
        else:
15243 
          iprot.skip(ftype)
15244 
      elif fid == 3:
6039 amit.gupta 15245 
        if ftype == TType.DOUBLE:
15246 
          self.price = iprot.readDouble();
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('getVatPercentageForItem_args')
15259 
    if self.itemId is not None:
15260 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15261 
      oprot.writeI64(self.itemId)
15262 
      oprot.writeFieldEnd()
7330 amit.gupta 15263 
    if self.stateId is not None:
15264 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15265 
      oprot.writeI64(self.stateId)
15266 
      oprot.writeFieldEnd()
6039 amit.gupta 15267 
    if self.price is not None:
7330 amit.gupta 15268 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15269 
      oprot.writeDouble(self.price)
15270 
      oprot.writeFieldEnd()
15271 
    oprot.writeFieldStop()
15272 
    oprot.writeStructEnd()
15273 
 
15274 
  def validate(self):
15275 
    return
15276 
 
15277 
 
15278 
  def __repr__(self):
15279 
    L = ['%s=%r' % (key, value)
15280 
      for key, value in self.__dict__.iteritems()]
15281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15282 
 
15283 
  def __eq__(self, other):
15284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15285 
 
15286 
  def __ne__(self, other):
15287 
    return not (self == other)
15288 
 
15289 
class getVatPercentageForItem_result:
15290 
  """
15291 
  Attributes:
15292 
   - success
7340 amit.gupta 15293 
   - cex
6039 amit.gupta 15294 
  """
15295 
 
15296 
  thrift_spec = (
15297 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15298 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15299 
  )
15300 
 
7340 amit.gupta 15301 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15302 
    self.success = success
7340 amit.gupta 15303 
    self.cex = cex
6039 amit.gupta 15304 
 
15305 
  def read(self, iprot):
15306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15308 
      return
15309 
    iprot.readStructBegin()
15310 
    while True:
15311 
      (fname, ftype, fid) = iprot.readFieldBegin()
15312 
      if ftype == TType.STOP:
15313 
        break
15314 
      if fid == 0:
15315 
        if ftype == TType.DOUBLE:
15316 
          self.success = iprot.readDouble();
15317 
        else:
15318 
          iprot.skip(ftype)
7340 amit.gupta 15319 
      elif fid == 1:
15320 
        if ftype == TType.STRUCT:
15321 
          self.cex = CatalogServiceException()
15322 
          self.cex.read(iprot)
15323 
        else:
15324 
          iprot.skip(ftype)
6039 amit.gupta 15325 
      else:
15326 
        iprot.skip(ftype)
15327 
      iprot.readFieldEnd()
15328 
    iprot.readStructEnd()
15329 
 
15330 
  def write(self, oprot):
15331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15333 
      return
15334 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15335 
    if self.success is not None:
15336 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15337 
      oprot.writeDouble(self.success)
15338 
      oprot.writeFieldEnd()
7340 amit.gupta 15339 
    if self.cex is not None:
15340 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15341 
      self.cex.write(oprot)
15342 
      oprot.writeFieldEnd()
6039 amit.gupta 15343 
    oprot.writeFieldStop()
15344 
    oprot.writeStructEnd()
15345 
 
15346 
  def validate(self):
15347 
    return
15348 
 
15349 
 
15350 
  def __repr__(self):
15351 
    L = ['%s=%r' % (key, value)
15352 
      for key, value in self.__dict__.iteritems()]
15353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15354 
 
15355 
  def __eq__(self, other):
15356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15357 
 
15358 
  def __ne__(self, other):
15359 
    return not (self == other)
15360 
 
15361 
class getVatAmountForItem_args:
15362 
  """
15363 
  Attributes:
15364 
   - itemId
15365 
   - price
15366 
  """
15367 
 
15368 
  thrift_spec = (
15369 
    None, # 0
15370 
    (1, TType.I64, 'itemId', None, None, ), # 1
15371 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15372 
  )
15373 
 
15374 
  def __init__(self, itemId=None, price=None,):
15375 
    self.itemId = itemId
15376 
    self.price = price
15377 
 
15378 
  def read(self, iprot):
15379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15381 
      return
15382 
    iprot.readStructBegin()
15383 
    while True:
15384 
      (fname, ftype, fid) = iprot.readFieldBegin()
15385 
      if ftype == TType.STOP:
15386 
        break
15387 
      if fid == 1:
15388 
        if ftype == TType.I64:
15389 
          self.itemId = iprot.readI64();
15390 
        else:
15391 
          iprot.skip(ftype)
15392 
      elif fid == 2:
15393 
        if ftype == TType.DOUBLE:
15394 
          self.price = iprot.readDouble();
15395 
        else:
15396 
          iprot.skip(ftype)
15397 
      else:
15398 
        iprot.skip(ftype)
15399 
      iprot.readFieldEnd()
15400 
    iprot.readStructEnd()
15401 
 
15402 
  def write(self, oprot):
15403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15405 
      return
15406 
    oprot.writeStructBegin('getVatAmountForItem_args')
15407 
    if self.itemId is not None:
15408 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15409 
      oprot.writeI64(self.itemId)
15410 
      oprot.writeFieldEnd()
15411 
    if self.price is not None:
15412 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15413 
      oprot.writeDouble(self.price)
15414 
      oprot.writeFieldEnd()
15415 
    oprot.writeFieldStop()
15416 
    oprot.writeStructEnd()
15417 
 
15418 
  def validate(self):
15419 
    return
15420 
 
15421 
 
15422 
  def __repr__(self):
15423 
    L = ['%s=%r' % (key, value)
15424 
      for key, value in self.__dict__.iteritems()]
15425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15426 
 
15427 
  def __eq__(self, other):
15428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15429 
 
15430 
  def __ne__(self, other):
15431 
    return not (self == other)
15432 
 
15433 
class getVatAmountForItem_result:
15434 
  """
15435 
  Attributes:
15436 
   - success
15437 
  """
15438 
 
15439 
  thrift_spec = (
15440 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15441 
  )
15442 
 
15443 
  def __init__(self, success=None,):
15444 
    self.success = success
15445 
 
15446 
  def read(self, iprot):
15447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15449 
      return
15450 
    iprot.readStructBegin()
15451 
    while True:
15452 
      (fname, ftype, fid) = iprot.readFieldBegin()
15453 
      if ftype == TType.STOP:
15454 
        break
15455 
      if fid == 0:
15456 
        if ftype == TType.DOUBLE:
15457 
          self.success = iprot.readDouble();
15458 
        else:
15459 
          iprot.skip(ftype)
15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('getVatAmountForItem_result')
15470 
    if self.success is not None:
15471 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15472 
      oprot.writeDouble(self.success)
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
6531 vikram.rag 15491 
 
15492 
class getAllIgnoredInventoryUpdateItemsList_args:
15493 
  """
15494 
  Attributes:
15495 
   - offset
15496 
   - limit
15497 
  """
15498 
 
15499 
  thrift_spec = (
15500 
    None, # 0
15501 
    (1, TType.I32, 'offset', None, None, ), # 1
15502 
    (2, TType.I32, 'limit', None, None, ), # 2
15503 
  )
15504 
 
15505 
  def __init__(self, offset=None, limit=None,):
15506 
    self.offset = offset
15507 
    self.limit = limit
15508 
 
15509 
  def read(self, iprot):
15510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15512 
      return
15513 
    iprot.readStructBegin()
15514 
    while True:
15515 
      (fname, ftype, fid) = iprot.readFieldBegin()
15516 
      if ftype == TType.STOP:
15517 
        break
15518 
      if fid == 1:
15519 
        if ftype == TType.I32:
15520 
          self.offset = iprot.readI32();
15521 
        else:
15522 
          iprot.skip(ftype)
15523 
      elif fid == 2:
15524 
        if ftype == TType.I32:
15525 
          self.limit = iprot.readI32();
15526 
        else:
15527 
          iprot.skip(ftype)
15528 
      else:
15529 
        iprot.skip(ftype)
15530 
      iprot.readFieldEnd()
15531 
    iprot.readStructEnd()
15532 
 
15533 
  def write(self, oprot):
15534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15536 
      return
15537 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15538 
    if self.offset is not None:
15539 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15540 
      oprot.writeI32(self.offset)
15541 
      oprot.writeFieldEnd()
15542 
    if self.limit is not None:
15543 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15544 
      oprot.writeI32(self.limit)
15545 
      oprot.writeFieldEnd()
15546 
    oprot.writeFieldStop()
15547 
    oprot.writeStructEnd()
15548 
 
15549 
  def validate(self):
15550 
    return
15551 
 
15552 
 
15553 
  def __repr__(self):
15554 
    L = ['%s=%r' % (key, value)
15555 
      for key, value in self.__dict__.iteritems()]
15556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15557 
 
15558 
  def __eq__(self, other):
15559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15560 
 
15561 
  def __ne__(self, other):
15562 
    return not (self == other)
15563 
 
15564 
class getAllIgnoredInventoryUpdateItemsList_result:
15565 
  """
15566 
  Attributes:
15567 
   - success
15568 
  """
15569 
 
15570 
  thrift_spec = (
15571 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15572 
  )
15573 
 
15574 
  def __init__(self, success=None,):
15575 
    self.success = success
15576 
 
15577 
  def read(self, iprot):
15578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15580 
      return
15581 
    iprot.readStructBegin()
15582 
    while True:
15583 
      (fname, ftype, fid) = iprot.readFieldBegin()
15584 
      if ftype == TType.STOP:
15585 
        break
15586 
      if fid == 0:
15587 
        if ftype == TType.LIST:
15588 
          self.success = []
7438 amit.gupta 15589 
          (_etype296, _size293) = iprot.readListBegin()
15590 
          for _i297 in xrange(_size293):
15591 
            _elem298 = Item()
15592 
            _elem298.read(iprot)
15593 
            self.success.append(_elem298)
6531 vikram.rag 15594 
          iprot.readListEnd()
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
15606 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15607 
    if self.success is not None:
15608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15610 
      for iter299 in self.success:
15611 
        iter299.write(oprot)
6531 vikram.rag 15612 
      oprot.writeListEnd()
15613 
      oprot.writeFieldEnd()
15614 
    oprot.writeFieldStop()
15615 
    oprot.writeStructEnd()
15616 
 
15617 
  def validate(self):
15618 
    return
15619 
 
15620 
 
15621 
  def __repr__(self):
15622 
    L = ['%s=%r' % (key, value)
15623 
      for key, value in self.__dict__.iteritems()]
15624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15625 
 
15626 
  def __eq__(self, other):
15627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15628 
 
15629 
  def __ne__(self, other):
15630 
    return not (self == other)
6805 anupam.sin 15631 
 
6821 amar.kumar 15632 
class getAllAliveItems_args:
15633 
 
15634 
  thrift_spec = (
15635 
  )
15636 
 
15637 
  def read(self, iprot):
15638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15640 
      return
15641 
    iprot.readStructBegin()
15642 
    while True:
15643 
      (fname, ftype, fid) = iprot.readFieldBegin()
15644 
      if ftype == TType.STOP:
15645 
        break
15646 
      else:
15647 
        iprot.skip(ftype)
15648 
      iprot.readFieldEnd()
15649 
    iprot.readStructEnd()
15650 
 
15651 
  def write(self, oprot):
15652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15654 
      return
15655 
    oprot.writeStructBegin('getAllAliveItems_args')
15656 
    oprot.writeFieldStop()
15657 
    oprot.writeStructEnd()
15658 
 
15659 
  def validate(self):
15660 
    return
15661 
 
15662 
 
15663 
  def __repr__(self):
15664 
    L = ['%s=%r' % (key, value)
15665 
      for key, value in self.__dict__.iteritems()]
15666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15667 
 
15668 
  def __eq__(self, other):
15669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15670 
 
15671 
  def __ne__(self, other):
15672 
    return not (self == other)
15673 
 
15674 
class getAllAliveItems_result:
15675 
  """
15676 
  Attributes:
15677 
   - success
15678 
  """
15679 
 
15680 
  thrift_spec = (
15681 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15682 
  )
15683 
 
15684 
  def __init__(self, success=None,):
15685 
    self.success = success
15686 
 
15687 
  def read(self, iprot):
15688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15690 
      return
15691 
    iprot.readStructBegin()
15692 
    while True:
15693 
      (fname, ftype, fid) = iprot.readFieldBegin()
15694 
      if ftype == TType.STOP:
15695 
        break
15696 
      if fid == 0:
15697 
        if ftype == TType.LIST:
15698 
          self.success = []
7438 amit.gupta 15699 
          (_etype303, _size300) = iprot.readListBegin()
15700 
          for _i304 in xrange(_size300):
15701 
            _elem305 = Item()
15702 
            _elem305.read(iprot)
15703 
            self.success.append(_elem305)
6821 amar.kumar 15704 
          iprot.readListEnd()
15705 
        else:
15706 
          iprot.skip(ftype)
15707 
      else:
15708 
        iprot.skip(ftype)
15709 
      iprot.readFieldEnd()
15710 
    iprot.readStructEnd()
15711 
 
15712 
  def write(self, oprot):
15713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15715 
      return
15716 
    oprot.writeStructBegin('getAllAliveItems_result')
15717 
    if self.success is not None:
15718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15720 
      for iter306 in self.success:
15721 
        iter306.write(oprot)
6821 amar.kumar 15722 
      oprot.writeListEnd()
15723 
      oprot.writeFieldEnd()
15724 
    oprot.writeFieldStop()
15725 
    oprot.writeStructEnd()
15726 
 
15727 
  def validate(self):
15728 
    return
15729 
 
15730 
 
15731 
  def __repr__(self):
15732 
    L = ['%s=%r' % (key, value)
15733 
      for key, value in self.__dict__.iteritems()]
15734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15735 
 
15736 
  def __eq__(self, other):
15737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15738 
 
15739 
  def __ne__(self, other):
15740 
    return not (self == other)
15741 
 
6805 anupam.sin 15742 
class getInsuranceAmount_args:
15743 
  """
15744 
  Attributes:
15745 
   - itemId
6921 anupam.sin 15746 
   - price
6805 anupam.sin 15747 
   - insurerId
15748 
   - quantity
15749 
  """
15750 
 
15751 
  thrift_spec = (
15752 
    None, # 0
15753 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15754 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15755 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15756 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15757 
  )
15758 
 
6921 anupam.sin 15759 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15760 
    self.itemId = itemId
6921 anupam.sin 15761 
    self.price = price
6805 anupam.sin 15762 
    self.insurerId = insurerId
15763 
    self.quantity = quantity
15764 
 
15765 
  def read(self, iprot):
15766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15768 
      return
15769 
    iprot.readStructBegin()
15770 
    while True:
15771 
      (fname, ftype, fid) = iprot.readFieldBegin()
15772 
      if ftype == TType.STOP:
15773 
        break
15774 
      if fid == 1:
15775 
        if ftype == TType.I64:
15776 
          self.itemId = iprot.readI64();
15777 
        else:
15778 
          iprot.skip(ftype)
15779 
      elif fid == 2:
6921 anupam.sin 15780 
        if ftype == TType.DOUBLE:
15781 
          self.price = iprot.readDouble();
15782 
        else:
15783 
          iprot.skip(ftype)
15784 
      elif fid == 3:
6805 anupam.sin 15785 
        if ftype == TType.I64:
15786 
          self.insurerId = iprot.readI64();
15787 
        else:
15788 
          iprot.skip(ftype)
6921 anupam.sin 15789 
      elif fid == 4:
6805 anupam.sin 15790 
        if ftype == TType.I64:
15791 
          self.quantity = iprot.readI64();
15792 
        else:
15793 
          iprot.skip(ftype)
15794 
      else:
15795 
        iprot.skip(ftype)
15796 
      iprot.readFieldEnd()
15797 
    iprot.readStructEnd()
15798 
 
15799 
  def write(self, oprot):
15800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15802 
      return
15803 
    oprot.writeStructBegin('getInsuranceAmount_args')
15804 
    if self.itemId is not None:
15805 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15806 
      oprot.writeI64(self.itemId)
15807 
      oprot.writeFieldEnd()
6921 anupam.sin 15808 
    if self.price is not None:
15809 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15810 
      oprot.writeDouble(self.price)
15811 
      oprot.writeFieldEnd()
6805 anupam.sin 15812 
    if self.insurerId is not None:
6921 anupam.sin 15813 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15814 
      oprot.writeI64(self.insurerId)
15815 
      oprot.writeFieldEnd()
15816 
    if self.quantity is not None:
6921 anupam.sin 15817 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15818 
      oprot.writeI64(self.quantity)
15819 
      oprot.writeFieldEnd()
15820 
    oprot.writeFieldStop()
15821 
    oprot.writeStructEnd()
15822 
 
15823 
  def validate(self):
15824 
    return
15825 
 
15826 
 
15827 
  def __repr__(self):
15828 
    L = ['%s=%r' % (key, value)
15829 
      for key, value in self.__dict__.iteritems()]
15830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15831 
 
15832 
  def __eq__(self, other):
15833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15834 
 
15835 
  def __ne__(self, other):
15836 
    return not (self == other)
15837 
 
15838 
class getInsuranceAmount_result:
15839 
  """
15840 
  Attributes:
15841 
   - success
15842 
  """
15843 
 
15844 
  thrift_spec = (
15845 
    (0, TType.I64, 'success', None, None, ), # 0
15846 
  )
15847 
 
15848 
  def __init__(self, success=None,):
15849 
    self.success = success
15850 
 
15851 
  def read(self, iprot):
15852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15854 
      return
15855 
    iprot.readStructBegin()
15856 
    while True:
15857 
      (fname, ftype, fid) = iprot.readFieldBegin()
15858 
      if ftype == TType.STOP:
15859 
        break
15860 
      if fid == 0:
15861 
        if ftype == TType.I64:
15862 
          self.success = iprot.readI64();
15863 
        else:
15864 
          iprot.skip(ftype)
15865 
      else:
15866 
        iprot.skip(ftype)
15867 
      iprot.readFieldEnd()
15868 
    iprot.readStructEnd()
15869 
 
15870 
  def write(self, oprot):
15871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15873 
      return
15874 
    oprot.writeStructBegin('getInsuranceAmount_result')
15875 
    if self.success is not None:
15876 
      oprot.writeFieldBegin('success', TType.I64, 0)
15877 
      oprot.writeI64(self.success)
15878 
      oprot.writeFieldEnd()
15879 
    oprot.writeFieldStop()
15880 
    oprot.writeStructEnd()
15881 
 
15882 
  def validate(self):
15883 
    return
15884 
 
15885 
 
15886 
  def __repr__(self):
15887 
    L = ['%s=%r' % (key, value)
15888 
      for key, value in self.__dict__.iteritems()]
15889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15890 
 
15891 
  def __eq__(self, other):
15892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15893 
 
15894 
  def __ne__(self, other):
15895 
    return not (self == other)
15896 
 
15897 
class getInsurer_args:
15898 
  """
15899 
  Attributes:
15900 
   - insurerId
15901 
  """
15902 
 
15903 
  thrift_spec = (
15904 
    None, # 0
15905 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15906 
  )
15907 
 
15908 
  def __init__(self, insurerId=None,):
15909 
    self.insurerId = insurerId
15910 
 
15911 
  def read(self, iprot):
15912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15914 
      return
15915 
    iprot.readStructBegin()
15916 
    while True:
15917 
      (fname, ftype, fid) = iprot.readFieldBegin()
15918 
      if ftype == TType.STOP:
15919 
        break
15920 
      if fid == 1:
15921 
        if ftype == TType.I64:
15922 
          self.insurerId = iprot.readI64();
15923 
        else:
15924 
          iprot.skip(ftype)
15925 
      else:
15926 
        iprot.skip(ftype)
15927 
      iprot.readFieldEnd()
15928 
    iprot.readStructEnd()
15929 
 
15930 
  def write(self, oprot):
15931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15933 
      return
15934 
    oprot.writeStructBegin('getInsurer_args')
15935 
    if self.insurerId is not None:
15936 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15937 
      oprot.writeI64(self.insurerId)
15938 
      oprot.writeFieldEnd()
15939 
    oprot.writeFieldStop()
15940 
    oprot.writeStructEnd()
15941 
 
15942 
  def validate(self):
15943 
    return
15944 
 
15945 
 
15946 
  def __repr__(self):
15947 
    L = ['%s=%r' % (key, value)
15948 
      for key, value in self.__dict__.iteritems()]
15949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15950 
 
15951 
  def __eq__(self, other):
15952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15953 
 
15954 
  def __ne__(self, other):
15955 
    return not (self == other)
15956 
 
15957 
class getInsurer_result:
15958 
  """
15959 
  Attributes:
15960 
   - success
15961 
  """
15962 
 
15963 
  thrift_spec = (
15964 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15965 
  )
15966 
 
15967 
  def __init__(self, success=None,):
15968 
    self.success = success
15969 
 
15970 
  def read(self, iprot):
15971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15973 
      return
15974 
    iprot.readStructBegin()
15975 
    while True:
15976 
      (fname, ftype, fid) = iprot.readFieldBegin()
15977 
      if ftype == TType.STOP:
15978 
        break
15979 
      if fid == 0:
15980 
        if ftype == TType.STRUCT:
15981 
          self.success = Insurer()
15982 
          self.success.read(iprot)
15983 
        else:
15984 
          iprot.skip(ftype)
15985 
      else:
15986 
        iprot.skip(ftype)
15987 
      iprot.readFieldEnd()
15988 
    iprot.readStructEnd()
15989 
 
15990 
  def write(self, oprot):
15991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15993 
      return
15994 
    oprot.writeStructBegin('getInsurer_result')
15995 
    if self.success is not None:
15996 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15997 
      self.success.write(oprot)
15998 
      oprot.writeFieldEnd()
15999 
    oprot.writeFieldStop()
16000 
    oprot.writeStructEnd()
16001 
 
16002 
  def validate(self):
16003 
    return
16004 
 
16005 
 
16006 
  def __repr__(self):
16007 
    L = ['%s=%r' % (key, value)
16008 
      for key, value in self.__dict__.iteritems()]
16009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16010 
 
16011 
  def __eq__(self, other):
16012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16013 
 
16014 
  def __ne__(self, other):
16015 
    return not (self == other)
6838 vikram.rag 16016 
 
16017 
class getAllInsurers_args:
16018 
 
16019 
  thrift_spec = (
16020 
  )
16021 
 
16022 
  def read(self, iprot):
16023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16025 
      return
16026 
    iprot.readStructBegin()
16027 
    while True:
16028 
      (fname, ftype, fid) = iprot.readFieldBegin()
16029 
      if ftype == TType.STOP:
16030 
        break
16031 
      else:
16032 
        iprot.skip(ftype)
16033 
      iprot.readFieldEnd()
16034 
    iprot.readStructEnd()
16035 
 
16036 
  def write(self, oprot):
16037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16039 
      return
16040 
    oprot.writeStructBegin('getAllInsurers_args')
16041 
    oprot.writeFieldStop()
16042 
    oprot.writeStructEnd()
16043 
 
16044 
  def validate(self):
16045 
    return
16046 
 
16047 
 
16048 
  def __repr__(self):
16049 
    L = ['%s=%r' % (key, value)
16050 
      for key, value in self.__dict__.iteritems()]
16051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16052 
 
16053 
  def __eq__(self, other):
16054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16055 
 
16056 
  def __ne__(self, other):
16057 
    return not (self == other)
16058 
 
16059 
class getAllInsurers_result:
16060 
  """
16061 
  Attributes:
16062 
   - success
16063 
  """
16064 
 
16065 
  thrift_spec = (
16066 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16067 
  )
16068 
 
16069 
  def __init__(self, success=None,):
16070 
    self.success = success
16071 
 
16072 
  def read(self, iprot):
16073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16075 
      return
16076 
    iprot.readStructBegin()
16077 
    while True:
16078 
      (fname, ftype, fid) = iprot.readFieldBegin()
16079 
      if ftype == TType.STOP:
16080 
        break
16081 
      if fid == 0:
16082 
        if ftype == TType.LIST:
16083 
          self.success = []
7438 amit.gupta 16084 
          (_etype310, _size307) = iprot.readListBegin()
16085 
          for _i311 in xrange(_size307):
16086 
            _elem312 = Insurer()
16087 
            _elem312.read(iprot)
16088 
            self.success.append(_elem312)
6838 vikram.rag 16089 
          iprot.readListEnd()
16090 
        else:
16091 
          iprot.skip(ftype)
16092 
      else:
16093 
        iprot.skip(ftype)
16094 
      iprot.readFieldEnd()
16095 
    iprot.readStructEnd()
16096 
 
16097 
  def write(self, oprot):
16098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16100 
      return
16101 
    oprot.writeStructBegin('getAllInsurers_result')
16102 
    if self.success is not None:
16103 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16104 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16105 
      for iter313 in self.success:
16106 
        iter313.write(oprot)
6838 vikram.rag 16107 
      oprot.writeListEnd()
16108 
      oprot.writeFieldEnd()
16109 
    oprot.writeFieldStop()
16110 
    oprot.writeStructEnd()
16111 
 
16112 
  def validate(self):
16113 
    return
16114 
 
16115 
 
16116 
  def __repr__(self):
16117 
    L = ['%s=%r' % (key, value)
16118 
      for key, value in self.__dict__.iteritems()]
16119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16120 
 
16121 
  def __eq__(self, other):
16122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16123 
 
16124 
  def __ne__(self, other):
16125 
    return not (self == other)
6962 rajveer 16126 
 
16127 
class updateInsuranceDeclaredAmount_args:
16128 
  """
16129 
  Attributes:
16130 
   - insurerId
16131 
   - amount
16132 
  """
16133 
 
16134 
  thrift_spec = (
16135 
    None, # 0
16136 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16137 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16138 
  )
16139 
 
16140 
  def __init__(self, insurerId=None, amount=None,):
16141 
    self.insurerId = insurerId
16142 
    self.amount = amount
16143 
 
16144 
  def read(self, iprot):
16145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16147 
      return
16148 
    iprot.readStructBegin()
16149 
    while True:
16150 
      (fname, ftype, fid) = iprot.readFieldBegin()
16151 
      if ftype == TType.STOP:
16152 
        break
16153 
      if fid == 1:
16154 
        if ftype == TType.I64:
16155 
          self.insurerId = iprot.readI64();
16156 
        else:
16157 
          iprot.skip(ftype)
16158 
      elif fid == 2:
16159 
        if ftype == TType.DOUBLE:
16160 
          self.amount = iprot.readDouble();
16161 
        else:
16162 
          iprot.skip(ftype)
16163 
      else:
16164 
        iprot.skip(ftype)
16165 
      iprot.readFieldEnd()
16166 
    iprot.readStructEnd()
16167 
 
16168 
  def write(self, oprot):
16169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16171 
      return
16172 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16173 
    if self.insurerId is not None:
16174 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16175 
      oprot.writeI64(self.insurerId)
16176 
      oprot.writeFieldEnd()
16177 
    if self.amount is not None:
16178 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16179 
      oprot.writeDouble(self.amount)
16180 
      oprot.writeFieldEnd()
16181 
    oprot.writeFieldStop()
16182 
    oprot.writeStructEnd()
16183 
 
16184 
  def validate(self):
16185 
    return
16186 
 
16187 
 
16188 
  def __repr__(self):
16189 
    L = ['%s=%r' % (key, value)
16190 
      for key, value in self.__dict__.iteritems()]
16191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16192 
 
16193 
  def __eq__(self, other):
16194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16195 
 
16196 
  def __ne__(self, other):
16197 
    return not (self == other)
16198 
 
16199 
class updateInsuranceDeclaredAmount_result:
16200 
 
16201 
  thrift_spec = (
16202 
  )
16203 
 
16204 
  def read(self, iprot):
16205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16207 
      return
16208 
    iprot.readStructBegin()
16209 
    while True:
16210 
      (fname, ftype, fid) = iprot.readFieldBegin()
16211 
      if ftype == TType.STOP:
16212 
        break
16213 
      else:
16214 
        iprot.skip(ftype)
16215 
      iprot.readFieldEnd()
16216 
    iprot.readStructEnd()
16217 
 
16218 
  def write(self, oprot):
16219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16221 
      return
16222 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16223 
    oprot.writeFieldStop()
16224 
    oprot.writeStructEnd()
16225 
 
16226 
  def validate(self):
16227 
    return
16228 
 
16229 
 
16230 
  def __repr__(self):
16231 
    L = ['%s=%r' % (key, value)
16232 
      for key, value in self.__dict__.iteritems()]
16233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16234 
 
16235 
  def __eq__(self, other):
16236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16237 
 
16238 
  def __ne__(self, other):
16239 
    return not (self == other)
7190 amar.kumar 16240 
 
16241 
class getFreebieForItem_args:
16242 
  """
16243 
  Attributes:
16244 
   - itemId
16245 
  """
16246 
 
16247 
  thrift_spec = (
16248 
    None, # 0
16249 
    (1, TType.I64, 'itemId', None, None, ), # 1
16250 
  )
16251 
 
16252 
  def __init__(self, itemId=None,):
16253 
    self.itemId = itemId
16254 
 
16255 
  def read(self, iprot):
16256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16258 
      return
16259 
    iprot.readStructBegin()
16260 
    while True:
16261 
      (fname, ftype, fid) = iprot.readFieldBegin()
16262 
      if ftype == TType.STOP:
16263 
        break
16264 
      if fid == 1:
16265 
        if ftype == TType.I64:
16266 
          self.itemId = iprot.readI64();
16267 
        else:
16268 
          iprot.skip(ftype)
16269 
      else:
16270 
        iprot.skip(ftype)
16271 
      iprot.readFieldEnd()
16272 
    iprot.readStructEnd()
16273 
 
16274 
  def write(self, oprot):
16275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16277 
      return
16278 
    oprot.writeStructBegin('getFreebieForItem_args')
16279 
    if self.itemId is not None:
16280 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16281 
      oprot.writeI64(self.itemId)
16282 
      oprot.writeFieldEnd()
16283 
    oprot.writeFieldStop()
16284 
    oprot.writeStructEnd()
16285 
 
16286 
  def validate(self):
16287 
    return
16288 
 
16289 
 
16290 
  def __repr__(self):
16291 
    L = ['%s=%r' % (key, value)
16292 
      for key, value in self.__dict__.iteritems()]
16293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16294 
 
16295 
  def __eq__(self, other):
16296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16297 
 
16298 
  def __ne__(self, other):
16299 
    return not (self == other)
16300 
 
16301 
class getFreebieForItem_result:
16302 
  """
16303 
  Attributes:
16304 
   - success
16305 
  """
16306 
 
16307 
  thrift_spec = (
16308 
    (0, TType.I64, 'success', None, None, ), # 0
16309 
  )
16310 
 
16311 
  def __init__(self, success=None,):
16312 
    self.success = success
16313 
 
16314 
  def read(self, iprot):
16315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16317 
      return
16318 
    iprot.readStructBegin()
16319 
    while True:
16320 
      (fname, ftype, fid) = iprot.readFieldBegin()
16321 
      if ftype == TType.STOP:
16322 
        break
16323 
      if fid == 0:
16324 
        if ftype == TType.I64:
16325 
          self.success = iprot.readI64();
16326 
        else:
16327 
          iprot.skip(ftype)
16328 
      else:
16329 
        iprot.skip(ftype)
16330 
      iprot.readFieldEnd()
16331 
    iprot.readStructEnd()
16332 
 
16333 
  def write(self, oprot):
16334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16336 
      return
16337 
    oprot.writeStructBegin('getFreebieForItem_result')
16338 
    if self.success is not None:
16339 
      oprot.writeFieldBegin('success', TType.I64, 0)
16340 
      oprot.writeI64(self.success)
16341 
      oprot.writeFieldEnd()
16342 
    oprot.writeFieldStop()
16343 
    oprot.writeStructEnd()
16344 
 
16345 
  def validate(self):
16346 
    return
16347 
 
16348 
 
16349 
  def __repr__(self):
16350 
    L = ['%s=%r' % (key, value)
16351 
      for key, value in self.__dict__.iteritems()]
16352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16353 
 
16354 
  def __eq__(self, other):
16355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16356 
 
16357 
  def __ne__(self, other):
16358 
    return not (self == other)
16359 
 
16360 
class addOrUpdateFreebieForItem_args:
16361 
  """
16362 
  Attributes:
16363 
   - freebieItem
16364 
  """
16365 
 
16366 
  thrift_spec = (
16367 
    None, # 0
16368 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16369 
  )
16370 
 
16371 
  def __init__(self, freebieItem=None,):
16372 
    self.freebieItem = freebieItem
16373 
 
16374 
  def read(self, iprot):
16375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16377 
      return
16378 
    iprot.readStructBegin()
16379 
    while True:
16380 
      (fname, ftype, fid) = iprot.readFieldBegin()
16381 
      if ftype == TType.STOP:
16382 
        break
16383 
      if fid == 1:
16384 
        if ftype == TType.STRUCT:
16385 
          self.freebieItem = FreebieItem()
16386 
          self.freebieItem.read(iprot)
16387 
        else:
16388 
          iprot.skip(ftype)
16389 
      else:
16390 
        iprot.skip(ftype)
16391 
      iprot.readFieldEnd()
16392 
    iprot.readStructEnd()
16393 
 
16394 
  def write(self, oprot):
16395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16397 
      return
16398 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16399 
    if self.freebieItem is not None:
16400 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16401 
      self.freebieItem.write(oprot)
16402 
      oprot.writeFieldEnd()
16403 
    oprot.writeFieldStop()
16404 
    oprot.writeStructEnd()
16405 
 
16406 
  def validate(self):
16407 
    return
16408 
 
16409 
 
16410 
  def __repr__(self):
16411 
    L = ['%s=%r' % (key, value)
16412 
      for key, value in self.__dict__.iteritems()]
16413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16414 
 
16415 
  def __eq__(self, other):
16416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16417 
 
16418 
  def __ne__(self, other):
16419 
    return not (self == other)
16420 
 
16421 
class addOrUpdateFreebieForItem_result:
16422 
 
16423 
  thrift_spec = (
16424 
  )
16425 
 
16426 
  def read(self, iprot):
16427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16429 
      return
16430 
    iprot.readStructBegin()
16431 
    while True:
16432 
      (fname, ftype, fid) = iprot.readFieldBegin()
16433 
      if ftype == TType.STOP:
16434 
        break
16435 
      else:
16436 
        iprot.skip(ftype)
16437 
      iprot.readFieldEnd()
16438 
    iprot.readStructEnd()
16439 
 
16440 
  def write(self, oprot):
16441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16443 
      return
16444 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16445 
    oprot.writeFieldStop()
16446 
    oprot.writeStructEnd()
16447 
 
16448 
  def validate(self):
16449 
    return
16450 
 
16451 
 
16452 
  def __repr__(self):
16453 
    L = ['%s=%r' % (key, value)
16454 
      for key, value in self.__dict__.iteritems()]
16455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16456 
 
16457 
  def __eq__(self, other):
16458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16459 
 
16460 
  def __ne__(self, other):
16461 
    return not (self == other)
7256 rajveer 16462 
 
7272 amit.gupta 16463 
class addOrUpdateBrandInfo_args:
16464 
  """
16465 
  Attributes:
16466 
   - brandInfo
16467 
  """
16468 
 
16469 
  thrift_spec = (
16470 
    None, # 0
16471 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16472 
  )
16473 
 
16474 
  def __init__(self, brandInfo=None,):
16475 
    self.brandInfo = brandInfo
16476 
 
16477 
  def read(self, iprot):
16478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16480 
      return
16481 
    iprot.readStructBegin()
16482 
    while True:
16483 
      (fname, ftype, fid) = iprot.readFieldBegin()
16484 
      if ftype == TType.STOP:
16485 
        break
16486 
      if fid == 1:
16487 
        if ftype == TType.STRUCT:
16488 
          self.brandInfo = BrandInfo()
16489 
          self.brandInfo.read(iprot)
16490 
        else:
16491 
          iprot.skip(ftype)
16492 
      else:
16493 
        iprot.skip(ftype)
16494 
      iprot.readFieldEnd()
16495 
    iprot.readStructEnd()
16496 
 
16497 
  def write(self, oprot):
16498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16500 
      return
16501 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16502 
    if self.brandInfo is not None:
16503 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16504 
      self.brandInfo.write(oprot)
16505 
      oprot.writeFieldEnd()
16506 
    oprot.writeFieldStop()
16507 
    oprot.writeStructEnd()
16508 
 
16509 
  def validate(self):
16510 
    return
16511 
 
16512 
 
16513 
  def __repr__(self):
16514 
    L = ['%s=%r' % (key, value)
16515 
      for key, value in self.__dict__.iteritems()]
16516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16517 
 
16518 
  def __eq__(self, other):
16519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16520 
 
16521 
  def __ne__(self, other):
16522 
    return not (self == other)
16523 
 
16524 
class addOrUpdateBrandInfo_result:
16525 
 
16526 
  thrift_spec = (
16527 
  )
16528 
 
16529 
  def read(self, iprot):
16530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16532 
      return
16533 
    iprot.readStructBegin()
16534 
    while True:
16535 
      (fname, ftype, fid) = iprot.readFieldBegin()
16536 
      if ftype == TType.STOP:
16537 
        break
16538 
      else:
16539 
        iprot.skip(ftype)
16540 
      iprot.readFieldEnd()
16541 
    iprot.readStructEnd()
16542 
 
16543 
  def write(self, oprot):
16544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16546 
      return
16547 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16548 
    oprot.writeFieldStop()
16549 
    oprot.writeStructEnd()
16550 
 
16551 
  def validate(self):
16552 
    return
16553 
 
16554 
 
16555 
  def __repr__(self):
16556 
    L = ['%s=%r' % (key, value)
16557 
      for key, value in self.__dict__.iteritems()]
16558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16559 
 
16560 
  def __eq__(self, other):
16561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16562 
 
16563 
  def __ne__(self, other):
16564 
    return not (self == other)
16565 
 
16566 
class getBrandInfo_args:
16567 
 
16568 
  thrift_spec = (
16569 
  )
16570 
 
16571 
  def read(self, iprot):
16572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16574 
      return
16575 
    iprot.readStructBegin()
16576 
    while True:
16577 
      (fname, ftype, fid) = iprot.readFieldBegin()
16578 
      if ftype == TType.STOP:
16579 
        break
16580 
      else:
16581 
        iprot.skip(ftype)
16582 
      iprot.readFieldEnd()
16583 
    iprot.readStructEnd()
16584 
 
16585 
  def write(self, oprot):
16586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16588 
      return
16589 
    oprot.writeStructBegin('getBrandInfo_args')
16590 
    oprot.writeFieldStop()
16591 
    oprot.writeStructEnd()
16592 
 
16593 
  def validate(self):
16594 
    return
16595 
 
16596 
 
16597 
  def __repr__(self):
16598 
    L = ['%s=%r' % (key, value)
16599 
      for key, value in self.__dict__.iteritems()]
16600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16601 
 
16602 
  def __eq__(self, other):
16603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16604 
 
16605 
  def __ne__(self, other):
16606 
    return not (self == other)
16607 
 
16608 
class getBrandInfo_result:
16609 
  """
16610 
  Attributes:
16611 
   - success
16612 
  """
16613 
 
16614 
  thrift_spec = (
16615 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16616 
  )
16617 
 
16618 
  def __init__(self, success=None,):
16619 
    self.success = success
16620 
 
16621 
  def read(self, iprot):
16622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16624 
      return
16625 
    iprot.readStructBegin()
16626 
    while True:
16627 
      (fname, ftype, fid) = iprot.readFieldBegin()
16628 
      if ftype == TType.STOP:
16629 
        break
16630 
      if fid == 0:
16631 
        if ftype == TType.MAP:
16632 
          self.success = {}
7438 amit.gupta 16633 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16634 
          for _i318 in xrange(_size314):
16635 
            _key319 = iprot.readString();
16636 
            _val320 = BrandInfo()
16637 
            _val320.read(iprot)
16638 
            self.success[_key319] = _val320
7272 amit.gupta 16639 
          iprot.readMapEnd()
16640 
        else:
16641 
          iprot.skip(ftype)
16642 
      else:
16643 
        iprot.skip(ftype)
16644 
      iprot.readFieldEnd()
16645 
    iprot.readStructEnd()
16646 
 
16647 
  def write(self, oprot):
16648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16650 
      return
16651 
    oprot.writeStructBegin('getBrandInfo_result')
16652 
    if self.success is not None:
16653 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16654 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16655 
      for kiter321,viter322 in self.success.items():
16656 
        oprot.writeString(kiter321)
16657 
        viter322.write(oprot)
7272 amit.gupta 16658 
      oprot.writeMapEnd()
16659 
      oprot.writeFieldEnd()
16660 
    oprot.writeFieldStop()
16661 
    oprot.writeStructEnd()
16662 
 
16663 
  def validate(self):
16664 
    return
16665 
 
16666 
 
16667 
  def __repr__(self):
16668 
    L = ['%s=%r' % (key, value)
16669 
      for key, value in self.__dict__.iteritems()]
16670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16671 
 
16672 
  def __eq__(self, other):
16673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16674 
 
16675 
  def __ne__(self, other):
16676 
    return not (self == other)
16677 
 
7256 rajveer 16678 
class getStorePricing_args:
16679 
  """
16680 
  Attributes:
16681 
   - itemId
16682 
  """
16683 
 
16684 
  thrift_spec = (
16685 
    None, # 0
16686 
    (1, TType.I64, 'itemId', None, None, ), # 1
16687 
  )
16688 
 
16689 
  def __init__(self, itemId=None,):
16690 
    self.itemId = itemId
16691 
 
16692 
  def read(self, iprot):
16693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16695 
      return
16696 
    iprot.readStructBegin()
16697 
    while True:
16698 
      (fname, ftype, fid) = iprot.readFieldBegin()
16699 
      if ftype == TType.STOP:
16700 
        break
16701 
      if fid == 1:
16702 
        if ftype == TType.I64:
16703 
          self.itemId = iprot.readI64();
16704 
        else:
16705 
          iprot.skip(ftype)
16706 
      else:
16707 
        iprot.skip(ftype)
16708 
      iprot.readFieldEnd()
16709 
    iprot.readStructEnd()
16710 
 
16711 
  def write(self, oprot):
16712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16714 
      return
16715 
    oprot.writeStructBegin('getStorePricing_args')
16716 
    if self.itemId is not None:
16717 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16718 
      oprot.writeI64(self.itemId)
16719 
      oprot.writeFieldEnd()
16720 
    oprot.writeFieldStop()
16721 
    oprot.writeStructEnd()
16722 
 
16723 
  def validate(self):
16724 
    return
16725 
 
16726 
 
16727 
  def __repr__(self):
16728 
    L = ['%s=%r' % (key, value)
16729 
      for key, value in self.__dict__.iteritems()]
16730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16731 
 
16732 
  def __eq__(self, other):
16733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16734 
 
16735 
  def __ne__(self, other):
16736 
    return not (self == other)
16737 
 
16738 
class getStorePricing_result:
16739 
  """
16740 
  Attributes:
16741 
   - success
16742 
  """
16743 
 
16744 
  thrift_spec = (
16745 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16746 
  )
16747 
 
16748 
  def __init__(self, success=None,):
16749 
    self.success = success
16750 
 
16751 
  def read(self, iprot):
16752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16754 
      return
16755 
    iprot.readStructBegin()
16756 
    while True:
16757 
      (fname, ftype, fid) = iprot.readFieldBegin()
16758 
      if ftype == TType.STOP:
16759 
        break
16760 
      if fid == 0:
16761 
        if ftype == TType.STRUCT:
16762 
          self.success = StorePricing()
16763 
          self.success.read(iprot)
16764 
        else:
16765 
          iprot.skip(ftype)
16766 
      else:
16767 
        iprot.skip(ftype)
16768 
      iprot.readFieldEnd()
16769 
    iprot.readStructEnd()
16770 
 
16771 
  def write(self, oprot):
16772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16774 
      return
16775 
    oprot.writeStructBegin('getStorePricing_result')
16776 
    if self.success is not None:
16777 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16778 
      self.success.write(oprot)
16779 
      oprot.writeFieldEnd()
16780 
    oprot.writeFieldStop()
16781 
    oprot.writeStructEnd()
16782 
 
16783 
  def validate(self):
16784 
    return
16785 
 
16786 
 
16787 
  def __repr__(self):
16788 
    L = ['%s=%r' % (key, value)
16789 
      for key, value in self.__dict__.iteritems()]
16790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16791 
 
16792 
  def __eq__(self, other):
16793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16794 
 
16795 
  def __ne__(self, other):
16796 
    return not (self == other)
7265 rajveer 16797 
 
7306 rajveer 16798 
class getStorePricings_args:
16799 
  """
16800 
  Attributes:
16801 
   - itemIds
16802 
  """
16803 
 
16804 
  thrift_spec = (
16805 
    None, # 0
16806 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16807 
  )
16808 
 
16809 
  def __init__(self, itemIds=None,):
16810 
    self.itemIds = itemIds
16811 
 
16812 
  def read(self, iprot):
16813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16815 
      return
16816 
    iprot.readStructBegin()
16817 
    while True:
16818 
      (fname, ftype, fid) = iprot.readFieldBegin()
16819 
      if ftype == TType.STOP:
16820 
        break
16821 
      if fid == 1:
16822 
        if ftype == TType.LIST:
16823 
          self.itemIds = []
7438 amit.gupta 16824 
          (_etype326, _size323) = iprot.readListBegin()
16825 
          for _i327 in xrange(_size323):
16826 
            _elem328 = iprot.readI64();
16827 
            self.itemIds.append(_elem328)
7306 rajveer 16828 
          iprot.readListEnd()
16829 
        else:
16830 
          iprot.skip(ftype)
16831 
      else:
16832 
        iprot.skip(ftype)
16833 
      iprot.readFieldEnd()
16834 
    iprot.readStructEnd()
16835 
 
16836 
  def write(self, oprot):
16837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16839 
      return
16840 
    oprot.writeStructBegin('getStorePricings_args')
16841 
    if self.itemIds is not None:
16842 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16843 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 16844 
      for iter329 in self.itemIds:
16845 
        oprot.writeI64(iter329)
7306 rajveer 16846 
      oprot.writeListEnd()
16847 
      oprot.writeFieldEnd()
16848 
    oprot.writeFieldStop()
16849 
    oprot.writeStructEnd()
16850 
 
16851 
  def validate(self):
16852 
    return
16853 
 
16854 
 
16855 
  def __repr__(self):
16856 
    L = ['%s=%r' % (key, value)
16857 
      for key, value in self.__dict__.iteritems()]
16858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16859 
 
16860 
  def __eq__(self, other):
16861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16862 
 
16863 
  def __ne__(self, other):
16864 
    return not (self == other)
16865 
 
16866 
class getStorePricings_result:
16867 
  """
16868 
  Attributes:
16869 
   - success
16870 
  """
16871 
 
16872 
  thrift_spec = (
16873 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16874 
  )
16875 
 
16876 
  def __init__(self, success=None,):
16877 
    self.success = success
16878 
 
16879 
  def read(self, iprot):
16880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16882 
      return
16883 
    iprot.readStructBegin()
16884 
    while True:
16885 
      (fname, ftype, fid) = iprot.readFieldBegin()
16886 
      if ftype == TType.STOP:
16887 
        break
16888 
      if fid == 0:
16889 
        if ftype == TType.LIST:
16890 
          self.success = []
7438 amit.gupta 16891 
          (_etype333, _size330) = iprot.readListBegin()
16892 
          for _i334 in xrange(_size330):
16893 
            _elem335 = StorePricing()
16894 
            _elem335.read(iprot)
16895 
            self.success.append(_elem335)
7306 rajveer 16896 
          iprot.readListEnd()
16897 
        else:
16898 
          iprot.skip(ftype)
16899 
      else:
16900 
        iprot.skip(ftype)
16901 
      iprot.readFieldEnd()
16902 
    iprot.readStructEnd()
16903 
 
16904 
  def write(self, oprot):
16905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16907 
      return
16908 
    oprot.writeStructBegin('getStorePricings_result')
16909 
    if self.success is not None:
16910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16911 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16912 
      for iter336 in self.success:
16913 
        iter336.write(oprot)
7306 rajveer 16914 
      oprot.writeListEnd()
16915 
      oprot.writeFieldEnd()
16916 
    oprot.writeFieldStop()
16917 
    oprot.writeStructEnd()
16918 
 
16919 
  def validate(self):
16920 
    return
16921 
 
16922 
 
16923 
  def __repr__(self):
16924 
    L = ['%s=%r' % (key, value)
16925 
      for key, value in self.__dict__.iteritems()]
16926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16927 
 
16928 
  def __eq__(self, other):
16929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16930 
 
16931 
  def __ne__(self, other):
16932 
    return not (self == other)
16933 
 
7265 rajveer 16934 
class updateStorePricing_args:
16935 
  """
16936 
  Attributes:
16937 
   - sp
7382 rajveer 16938 
   - allColors
7265 rajveer 16939 
  """
16940 
 
16941 
  thrift_spec = (
16942 
    None, # 0
16943 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 16944 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 16945 
  )
16946 
 
7382 rajveer 16947 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 16948 
    self.sp = sp
7382 rajveer 16949 
    self.allColors = allColors
7265 rajveer 16950 
 
16951 
  def read(self, iprot):
16952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16954 
      return
16955 
    iprot.readStructBegin()
16956 
    while True:
16957 
      (fname, ftype, fid) = iprot.readFieldBegin()
16958 
      if ftype == TType.STOP:
16959 
        break
16960 
      if fid == 1:
16961 
        if ftype == TType.STRUCT:
16962 
          self.sp = StorePricing()
16963 
          self.sp.read(iprot)
16964 
        else:
16965 
          iprot.skip(ftype)
7382 rajveer 16966 
      elif fid == 2:
16967 
        if ftype == TType.BOOL:
16968 
          self.allColors = iprot.readBool();
16969 
        else:
16970 
          iprot.skip(ftype)
7265 rajveer 16971 
      else:
16972 
        iprot.skip(ftype)
16973 
      iprot.readFieldEnd()
16974 
    iprot.readStructEnd()
16975 
 
16976 
  def write(self, oprot):
16977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16979 
      return
16980 
    oprot.writeStructBegin('updateStorePricing_args')
16981 
    if self.sp is not None:
16982 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16983 
      self.sp.write(oprot)
16984 
      oprot.writeFieldEnd()
7382 rajveer 16985 
    if self.allColors is not None:
16986 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
16987 
      oprot.writeBool(self.allColors)
16988 
      oprot.writeFieldEnd()
7265 rajveer 16989 
    oprot.writeFieldStop()
16990 
    oprot.writeStructEnd()
16991 
 
16992 
  def validate(self):
16993 
    return
16994 
 
16995 
 
16996 
  def __repr__(self):
16997 
    L = ['%s=%r' % (key, value)
16998 
      for key, value in self.__dict__.iteritems()]
16999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17000 
 
17001 
  def __eq__(self, other):
17002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17003 
 
17004 
  def __ne__(self, other):
17005 
    return not (self == other)
17006 
 
17007 
class updateStorePricing_result:
17008 
 
17009 
  thrift_spec = (
17010 
  )
17011 
 
17012 
  def read(self, iprot):
17013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17015 
      return
17016 
    iprot.readStructBegin()
17017 
    while True:
17018 
      (fname, ftype, fid) = iprot.readFieldBegin()
17019 
      if ftype == TType.STOP:
17020 
        break
17021 
      else:
17022 
        iprot.skip(ftype)
17023 
      iprot.readFieldEnd()
17024 
    iprot.readStructEnd()
17025 
 
17026 
  def write(self, oprot):
17027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17029 
      return
17030 
    oprot.writeStructBegin('updateStorePricing_result')
17031 
    oprot.writeFieldStop()
17032 
    oprot.writeStructEnd()
17033 
 
17034 
  def validate(self):
17035 
    return
17036 
 
17037 
 
17038 
  def __repr__(self):
17039 
    L = ['%s=%r' % (key, value)
17040 
      for key, value in self.__dict__.iteritems()]
17041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17042 
 
17043 
  def __eq__(self, other):
17044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17045 
 
17046 
  def __ne__(self, other):
17047 
    return not (self == other)
7281 kshitij.so 17048 
 
17049 
class getAllAmazonListedItems_args:
17050 
 
17051 
  thrift_spec = (
17052 
  )
17053 
 
17054 
  def read(self, iprot):
17055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17057 
      return
17058 
    iprot.readStructBegin()
17059 
    while True:
17060 
      (fname, ftype, fid) = iprot.readFieldBegin()
17061 
      if ftype == TType.STOP:
17062 
        break
17063 
      else:
17064 
        iprot.skip(ftype)
17065 
      iprot.readFieldEnd()
17066 
    iprot.readStructEnd()
17067 
 
17068 
  def write(self, oprot):
17069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17071 
      return
17072 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17073 
    oprot.writeFieldStop()
17074 
    oprot.writeStructEnd()
17075 
 
17076 
  def validate(self):
17077 
    return
17078 
 
17079 
 
17080 
  def __repr__(self):
17081 
    L = ['%s=%r' % (key, value)
17082 
      for key, value in self.__dict__.iteritems()]
17083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17084 
 
17085 
  def __eq__(self, other):
17086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17087 
 
17088 
  def __ne__(self, other):
17089 
    return not (self == other)
17090 
 
17091 
class getAllAmazonListedItems_result:
17092 
  """
17093 
  Attributes:
17094 
   - success
17095 
  """
17096 
 
17097 
  thrift_spec = (
17098 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17099 
  )
17100 
 
17101 
  def __init__(self, success=None,):
17102 
    self.success = success
17103 
 
17104 
  def read(self, iprot):
17105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17107 
      return
17108 
    iprot.readStructBegin()
17109 
    while True:
17110 
      (fname, ftype, fid) = iprot.readFieldBegin()
17111 
      if ftype == TType.STOP:
17112 
        break
17113 
      if fid == 0:
17114 
        if ftype == TType.LIST:
17115 
          self.success = []
7438 amit.gupta 17116 
          (_etype340, _size337) = iprot.readListBegin()
17117 
          for _i341 in xrange(_size337):
17118 
            _elem342 = Amazonlisted()
17119 
            _elem342.read(iprot)
17120 
            self.success.append(_elem342)
7281 kshitij.so 17121 
          iprot.readListEnd()
17122 
        else:
17123 
          iprot.skip(ftype)
17124 
      else:
17125 
        iprot.skip(ftype)
17126 
      iprot.readFieldEnd()
17127 
    iprot.readStructEnd()
17128 
 
17129 
  def write(self, oprot):
17130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17132 
      return
17133 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17134 
    if self.success is not None:
17135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17137 
      for iter343 in self.success:
17138 
        iter343.write(oprot)
7281 kshitij.so 17139 
      oprot.writeListEnd()
17140 
      oprot.writeFieldEnd()
17141 
    oprot.writeFieldStop()
17142 
    oprot.writeStructEnd()
17143 
 
17144 
  def validate(self):
17145 
    return
17146 
 
17147 
 
17148 
  def __repr__(self):
17149 
    L = ['%s=%r' % (key, value)
17150 
      for key, value in self.__dict__.iteritems()]
17151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17152 
 
17153 
  def __eq__(self, other):
17154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17155 
 
17156 
  def __ne__(self, other):
17157 
    return not (self == other)
17158 
 
17159 
class getAmazonItemDetails_args:
17160 
  """
17161 
  Attributes:
17162 
   - itemId
17163 
  """
17164 
 
17165 
  thrift_spec = (
17166 
    None, # 0
17167 
    (1, TType.I64, 'itemId', None, None, ), # 1
17168 
  )
17169 
 
17170 
  def __init__(self, itemId=None,):
17171 
    self.itemId = itemId
17172 
 
17173 
  def read(self, iprot):
17174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17176 
      return
17177 
    iprot.readStructBegin()
17178 
    while True:
17179 
      (fname, ftype, fid) = iprot.readFieldBegin()
17180 
      if ftype == TType.STOP:
17181 
        break
17182 
      if fid == 1:
17183 
        if ftype == TType.I64:
17184 
          self.itemId = iprot.readI64();
17185 
        else:
17186 
          iprot.skip(ftype)
17187 
      else:
17188 
        iprot.skip(ftype)
17189 
      iprot.readFieldEnd()
17190 
    iprot.readStructEnd()
17191 
 
17192 
  def write(self, oprot):
17193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17195 
      return
17196 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17197 
    if self.itemId is not None:
17198 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17199 
      oprot.writeI64(self.itemId)
17200 
      oprot.writeFieldEnd()
17201 
    oprot.writeFieldStop()
17202 
    oprot.writeStructEnd()
17203 
 
17204 
  def validate(self):
17205 
    return
17206 
 
17207 
 
17208 
  def __repr__(self):
17209 
    L = ['%s=%r' % (key, value)
17210 
      for key, value in self.__dict__.iteritems()]
17211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17212 
 
17213 
  def __eq__(self, other):
17214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17215 
 
17216 
  def __ne__(self, other):
17217 
    return not (self == other)
17218 
 
17219 
class getAmazonItemDetails_result:
17220 
  """
17221 
  Attributes:
17222 
   - success
17223 
  """
17224 
 
17225 
  thrift_spec = (
17226 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17227 
  )
17228 
 
17229 
  def __init__(self, success=None,):
17230 
    self.success = success
17231 
 
17232 
  def read(self, iprot):
17233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17235 
      return
17236 
    iprot.readStructBegin()
17237 
    while True:
17238 
      (fname, ftype, fid) = iprot.readFieldBegin()
17239 
      if ftype == TType.STOP:
17240 
        break
17241 
      if fid == 0:
17242 
        if ftype == TType.STRUCT:
17243 
          self.success = Amazonlisted()
17244 
          self.success.read(iprot)
17245 
        else:
17246 
          iprot.skip(ftype)
17247 
      else:
17248 
        iprot.skip(ftype)
17249 
      iprot.readFieldEnd()
17250 
    iprot.readStructEnd()
17251 
 
17252 
  def write(self, oprot):
17253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17255 
      return
17256 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17257 
    if self.success is not None:
17258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17259 
      self.success.write(oprot)
17260 
      oprot.writeFieldEnd()
17261 
    oprot.writeFieldStop()
17262 
    oprot.writeStructEnd()
17263 
 
17264 
  def validate(self):
17265 
    return
17266 
 
17267 
 
17268 
  def __repr__(self):
17269 
    L = ['%s=%r' % (key, value)
17270 
      for key, value in self.__dict__.iteritems()]
17271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17272 
 
17273 
  def __eq__(self, other):
17274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17275 
 
17276 
  def __ne__(self, other):
17277 
    return not (self == other)
17278 
 
17279 
class updateAmazonItemDetails_args:
17280 
  """
17281 
  Attributes:
17282 
   - itemId
17283 
   - fbaPrice
17284 
   - sellingPrice
17285 
   - isFba
17286 
   - isNonFba
17287 
   - isInventoryOverride
7367 kshitij.so 17288 
   - handlingTime
17289 
   - isCustomTime
7281 kshitij.so 17290 
  """
17291 
 
17292 
  thrift_spec = (
17293 
    None, # 0
17294 
    (1, TType.I64, 'itemId', None, None, ), # 1
17295 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
17296 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
17297 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
17298 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
17299 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 17300 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
17301 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 17302 
  )
17303 
 
7367 kshitij.so 17304 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 17305 
    self.itemId = itemId
17306 
    self.fbaPrice = fbaPrice
17307 
    self.sellingPrice = sellingPrice
17308 
    self.isFba = isFba
17309 
    self.isNonFba = isNonFba
17310 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 17311 
    self.handlingTime = handlingTime
17312 
    self.isCustomTime = isCustomTime
7281 kshitij.so 17313 
 
17314 
  def read(self, iprot):
17315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17317 
      return
17318 
    iprot.readStructBegin()
17319 
    while True:
17320 
      (fname, ftype, fid) = iprot.readFieldBegin()
17321 
      if ftype == TType.STOP:
17322 
        break
17323 
      if fid == 1:
17324 
        if ftype == TType.I64:
17325 
          self.itemId = iprot.readI64();
17326 
        else:
17327 
          iprot.skip(ftype)
17328 
      elif fid == 2:
17329 
        if ftype == TType.DOUBLE:
17330 
          self.fbaPrice = iprot.readDouble();
17331 
        else:
17332 
          iprot.skip(ftype)
17333 
      elif fid == 3:
17334 
        if ftype == TType.DOUBLE:
17335 
          self.sellingPrice = iprot.readDouble();
17336 
        else:
17337 
          iprot.skip(ftype)
17338 
      elif fid == 4:
17339 
        if ftype == TType.BOOL:
17340 
          self.isFba = iprot.readBool();
17341 
        else:
17342 
          iprot.skip(ftype)
17343 
      elif fid == 5:
17344 
        if ftype == TType.BOOL:
17345 
          self.isNonFba = iprot.readBool();
17346 
        else:
17347 
          iprot.skip(ftype)
17348 
      elif fid == 6:
17349 
        if ftype == TType.BOOL:
17350 
          self.isInventoryOverride = iprot.readBool();
17351 
        else:
17352 
          iprot.skip(ftype)
7367 kshitij.so 17353 
      elif fid == 7:
17354 
        if ftype == TType.I64:
17355 
          self.handlingTime = iprot.readI64();
17356 
        else:
17357 
          iprot.skip(ftype)
17358 
      elif fid == 8:
17359 
        if ftype == TType.BOOL:
17360 
          self.isCustomTime = iprot.readBool();
17361 
        else:
17362 
          iprot.skip(ftype)
7281 kshitij.so 17363 
      else:
17364 
        iprot.skip(ftype)
17365 
      iprot.readFieldEnd()
17366 
    iprot.readStructEnd()
17367 
 
17368 
  def write(self, oprot):
17369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17371 
      return
17372 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17373 
    if self.itemId is not None:
17374 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17375 
      oprot.writeI64(self.itemId)
17376 
      oprot.writeFieldEnd()
17377 
    if self.fbaPrice is not None:
17378 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17379 
      oprot.writeDouble(self.fbaPrice)
17380 
      oprot.writeFieldEnd()
17381 
    if self.sellingPrice is not None:
17382 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17383 
      oprot.writeDouble(self.sellingPrice)
17384 
      oprot.writeFieldEnd()
17385 
    if self.isFba is not None:
17386 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17387 
      oprot.writeBool(self.isFba)
17388 
      oprot.writeFieldEnd()
17389 
    if self.isNonFba is not None:
17390 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17391 
      oprot.writeBool(self.isNonFba)
17392 
      oprot.writeFieldEnd()
17393 
    if self.isInventoryOverride is not None:
17394 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17395 
      oprot.writeBool(self.isInventoryOverride)
17396 
      oprot.writeFieldEnd()
7367 kshitij.so 17397 
    if self.handlingTime is not None:
17398 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17399 
      oprot.writeI64(self.handlingTime)
17400 
      oprot.writeFieldEnd()
17401 
    if self.isCustomTime is not None:
17402 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17403 
      oprot.writeBool(self.isCustomTime)
17404 
      oprot.writeFieldEnd()
7281 kshitij.so 17405 
    oprot.writeFieldStop()
17406 
    oprot.writeStructEnd()
17407 
 
17408 
  def validate(self):
17409 
    return
17410 
 
17411 
 
17412 
  def __repr__(self):
17413 
    L = ['%s=%r' % (key, value)
17414 
      for key, value in self.__dict__.iteritems()]
17415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17416 
 
17417 
  def __eq__(self, other):
17418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17419 
 
17420 
  def __ne__(self, other):
17421 
    return not (self == other)
17422 
 
17423 
class updateAmazonItemDetails_result:
17424 
 
17425 
  thrift_spec = (
17426 
  )
17427 
 
17428 
  def read(self, iprot):
17429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17431 
      return
17432 
    iprot.readStructBegin()
17433 
    while True:
17434 
      (fname, ftype, fid) = iprot.readFieldBegin()
17435 
      if ftype == TType.STOP:
17436 
        break
17437 
      else:
17438 
        iprot.skip(ftype)
17439 
      iprot.readFieldEnd()
17440 
    iprot.readStructEnd()
17441 
 
17442 
  def write(self, oprot):
17443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17445 
      return
17446 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17447 
    oprot.writeFieldStop()
17448 
    oprot.writeStructEnd()
17449 
 
17450 
  def validate(self):
17451 
    return
17452 
 
17453 
 
17454 
  def __repr__(self):
17455 
    L = ['%s=%r' % (key, value)
17456 
      for key, value in self.__dict__.iteritems()]
17457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17458 
 
17459 
  def __eq__(self, other):
17460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17461 
 
17462 
  def __ne__(self, other):
17463 
    return not (self == other)
17464 
 
17465 
class addAmazonItem_args:
17466 
  """
17467 
  Attributes:
17468 
   - amazonlisted
17469 
  """
17470 
 
17471 
  thrift_spec = (
17472 
    None, # 0
17473 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17474 
  )
17475 
 
17476 
  def __init__(self, amazonlisted=None,):
17477 
    self.amazonlisted = amazonlisted
17478 
 
17479 
  def read(self, iprot):
17480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17482 
      return
17483 
    iprot.readStructBegin()
17484 
    while True:
17485 
      (fname, ftype, fid) = iprot.readFieldBegin()
17486 
      if ftype == TType.STOP:
17487 
        break
17488 
      if fid == 1:
17489 
        if ftype == TType.STRUCT:
17490 
          self.amazonlisted = Amazonlisted()
17491 
          self.amazonlisted.read(iprot)
17492 
        else:
17493 
          iprot.skip(ftype)
17494 
      else:
17495 
        iprot.skip(ftype)
17496 
      iprot.readFieldEnd()
17497 
    iprot.readStructEnd()
17498 
 
17499 
  def write(self, oprot):
17500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17502 
      return
17503 
    oprot.writeStructBegin('addAmazonItem_args')
17504 
    if self.amazonlisted is not None:
17505 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17506 
      self.amazonlisted.write(oprot)
17507 
      oprot.writeFieldEnd()
17508 
    oprot.writeFieldStop()
17509 
    oprot.writeStructEnd()
17510 
 
17511 
  def validate(self):
17512 
    return
17513 
 
17514 
 
17515 
  def __repr__(self):
17516 
    L = ['%s=%r' % (key, value)
17517 
      for key, value in self.__dict__.iteritems()]
17518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17519 
 
17520 
  def __eq__(self, other):
17521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17522 
 
17523 
  def __ne__(self, other):
17524 
    return not (self == other)
17525 
 
17526 
class addAmazonItem_result:
17527 
 
17528 
  thrift_spec = (
17529 
  )
17530 
 
17531 
  def read(self, iprot):
17532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17534 
      return
17535 
    iprot.readStructBegin()
17536 
    while True:
17537 
      (fname, ftype, fid) = iprot.readFieldBegin()
17538 
      if ftype == TType.STOP:
17539 
        break
17540 
      else:
17541 
        iprot.skip(ftype)
17542 
      iprot.readFieldEnd()
17543 
    iprot.readStructEnd()
17544 
 
17545 
  def write(self, oprot):
17546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17548 
      return
17549 
    oprot.writeStructBegin('addAmazonItem_result')
17550 
    oprot.writeFieldStop()
17551 
    oprot.writeStructEnd()
17552 
 
17553 
  def validate(self):
17554 
    return
17555 
 
17556 
 
17557 
  def __repr__(self):
17558 
    L = ['%s=%r' % (key, value)
17559 
      for key, value in self.__dict__.iteritems()]
17560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17561 
 
17562 
  def __eq__(self, other):
17563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17564 
 
17565 
  def __ne__(self, other):
17566 
    return not (self == other)
7291 vikram.rag 17567 
 
17568 
class getAsinItems_args:
17569 
 
17570 
  thrift_spec = (
17571 
  )
17572 
 
17573 
  def read(self, iprot):
17574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17576 
      return
17577 
    iprot.readStructBegin()
17578 
    while True:
17579 
      (fname, ftype, fid) = iprot.readFieldBegin()
17580 
      if ftype == TType.STOP:
17581 
        break
17582 
      else:
17583 
        iprot.skip(ftype)
17584 
      iprot.readFieldEnd()
17585 
    iprot.readStructEnd()
17586 
 
17587 
  def write(self, oprot):
17588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17590 
      return
17591 
    oprot.writeStructBegin('getAsinItems_args')
17592 
    oprot.writeFieldStop()
17593 
    oprot.writeStructEnd()
17594 
 
17595 
  def validate(self):
17596 
    return
17597 
 
17598 
 
17599 
  def __repr__(self):
17600 
    L = ['%s=%r' % (key, value)
17601 
      for key, value in self.__dict__.iteritems()]
17602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17603 
 
17604 
  def __eq__(self, other):
17605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17606 
 
17607 
  def __ne__(self, other):
17608 
    return not (self == other)
17609 
 
17610 
class getAsinItems_result:
17611 
  """
17612 
  Attributes:
17613 
   - success
17614 
  """
17615 
 
17616 
  thrift_spec = (
17617 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17618 
  )
17619 
 
17620 
  def __init__(self, success=None,):
17621 
    self.success = success
17622 
 
17623 
  def read(self, iprot):
17624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17626 
      return
17627 
    iprot.readStructBegin()
17628 
    while True:
17629 
      (fname, ftype, fid) = iprot.readFieldBegin()
17630 
      if ftype == TType.STOP:
17631 
        break
17632 
      if fid == 0:
17633 
        if ftype == TType.LIST:
17634 
          self.success = []
7438 amit.gupta 17635 
          (_etype347, _size344) = iprot.readListBegin()
17636 
          for _i348 in xrange(_size344):
17637 
            _elem349 = Item()
17638 
            _elem349.read(iprot)
17639 
            self.success.append(_elem349)
7291 vikram.rag 17640 
          iprot.readListEnd()
17641 
        else:
17642 
          iprot.skip(ftype)
17643 
      else:
17644 
        iprot.skip(ftype)
17645 
      iprot.readFieldEnd()
17646 
    iprot.readStructEnd()
17647 
 
17648 
  def write(self, oprot):
17649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17651 
      return
17652 
    oprot.writeStructBegin('getAsinItems_result')
17653 
    if self.success is not None:
17654 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17655 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17656 
      for iter350 in self.success:
17657 
        iter350.write(oprot)
7291 vikram.rag 17658 
      oprot.writeListEnd()
17659 
      oprot.writeFieldEnd()
17660 
    oprot.writeFieldStop()
17661 
    oprot.writeStructEnd()
17662 
 
17663 
  def validate(self):
17664 
    return
17665 
 
17666 
 
17667 
  def __repr__(self):
17668 
    L = ['%s=%r' % (key, value)
17669 
      for key, value in self.__dict__.iteritems()]
17670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17671 
 
17672 
  def __eq__(self, other):
17673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17674 
 
17675 
  def __ne__(self, other):
17676 
    return not (self == other)
17677 
 
17678 
class getAllFbaListedItems_args:
17679 
 
17680 
  thrift_spec = (
17681 
  )
17682 
 
17683 
  def read(self, iprot):
17684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17686 
      return
17687 
    iprot.readStructBegin()
17688 
    while True:
17689 
      (fname, ftype, fid) = iprot.readFieldBegin()
17690 
      if ftype == TType.STOP:
17691 
        break
17692 
      else:
17693 
        iprot.skip(ftype)
17694 
      iprot.readFieldEnd()
17695 
    iprot.readStructEnd()
17696 
 
17697 
  def write(self, oprot):
17698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17700 
      return
17701 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17702 
    oprot.writeFieldStop()
17703 
    oprot.writeStructEnd()
17704 
 
17705 
  def validate(self):
17706 
    return
17707 
 
17708 
 
17709 
  def __repr__(self):
17710 
    L = ['%s=%r' % (key, value)
17711 
      for key, value in self.__dict__.iteritems()]
17712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17713 
 
17714 
  def __eq__(self, other):
17715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17716 
 
17717 
  def __ne__(self, other):
17718 
    return not (self == other)
17719 
 
17720 
class getAllFbaListedItems_result:
17721 
  """
17722 
  Attributes:
17723 
   - success
17724 
  """
17725 
 
17726 
  thrift_spec = (
17727 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17728 
  )
17729 
 
17730 
  def __init__(self, success=None,):
17731 
    self.success = success
17732 
 
17733 
  def read(self, iprot):
17734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17736 
      return
17737 
    iprot.readStructBegin()
17738 
    while True:
17739 
      (fname, ftype, fid) = iprot.readFieldBegin()
17740 
      if ftype == TType.STOP:
17741 
        break
17742 
      if fid == 0:
17743 
        if ftype == TType.LIST:
17744 
          self.success = []
7438 amit.gupta 17745 
          (_etype354, _size351) = iprot.readListBegin()
17746 
          for _i355 in xrange(_size351):
17747 
            _elem356 = Amazonlisted()
17748 
            _elem356.read(iprot)
17749 
            self.success.append(_elem356)
7291 vikram.rag 17750 
          iprot.readListEnd()
17751 
        else:
17752 
          iprot.skip(ftype)
17753 
      else:
17754 
        iprot.skip(ftype)
17755 
      iprot.readFieldEnd()
17756 
    iprot.readStructEnd()
17757 
 
17758 
  def write(self, oprot):
17759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17761 
      return
17762 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17763 
    if self.success is not None:
17764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17766 
      for iter357 in self.success:
17767 
        iter357.write(oprot)
7291 vikram.rag 17768 
      oprot.writeListEnd()
17769 
      oprot.writeFieldEnd()
17770 
    oprot.writeFieldStop()
17771 
    oprot.writeStructEnd()
17772 
 
17773 
  def validate(self):
17774 
    return
17775 
 
17776 
 
17777 
  def __repr__(self):
17778 
    L = ['%s=%r' % (key, value)
17779 
      for key, value in self.__dict__.iteritems()]
17780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17781 
 
17782 
  def __eq__(self, other):
17783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17784 
 
17785 
  def __ne__(self, other):
17786 
    return not (self == other)
17787 
 
17788 
class getAllNonFbaListedItems_args:
17789 
 
17790 
  thrift_spec = (
17791 
  )
17792 
 
17793 
  def read(self, iprot):
17794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17796 
      return
17797 
    iprot.readStructBegin()
17798 
    while True:
17799 
      (fname, ftype, fid) = iprot.readFieldBegin()
17800 
      if ftype == TType.STOP:
17801 
        break
17802 
      else:
17803 
        iprot.skip(ftype)
17804 
      iprot.readFieldEnd()
17805 
    iprot.readStructEnd()
17806 
 
17807 
  def write(self, oprot):
17808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17810 
      return
17811 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17812 
    oprot.writeFieldStop()
17813 
    oprot.writeStructEnd()
17814 
 
17815 
  def validate(self):
17816 
    return
17817 
 
17818 
 
17819 
  def __repr__(self):
17820 
    L = ['%s=%r' % (key, value)
17821 
      for key, value in self.__dict__.iteritems()]
17822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17823 
 
17824 
  def __eq__(self, other):
17825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17826 
 
17827 
  def __ne__(self, other):
17828 
    return not (self == other)
17829 
 
17830 
class getAllNonFbaListedItems_result:
17831 
  """
17832 
  Attributes:
17833 
   - success
17834 
  """
17835 
 
17836 
  thrift_spec = (
17837 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17838 
  )
17839 
 
17840 
  def __init__(self, success=None,):
17841 
    self.success = success
17842 
 
17843 
  def read(self, iprot):
17844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17846 
      return
17847 
    iprot.readStructBegin()
17848 
    while True:
17849 
      (fname, ftype, fid) = iprot.readFieldBegin()
17850 
      if ftype == TType.STOP:
17851 
        break
17852 
      if fid == 0:
17853 
        if ftype == TType.LIST:
17854 
          self.success = []
7438 amit.gupta 17855 
          (_etype361, _size358) = iprot.readListBegin()
17856 
          for _i362 in xrange(_size358):
17857 
            _elem363 = Amazonlisted()
17858 
            _elem363.read(iprot)
17859 
            self.success.append(_elem363)
7291 vikram.rag 17860 
          iprot.readListEnd()
17861 
        else:
17862 
          iprot.skip(ftype)
17863 
      else:
17864 
        iprot.skip(ftype)
17865 
      iprot.readFieldEnd()
17866 
    iprot.readStructEnd()
17867 
 
17868 
  def write(self, oprot):
17869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17871 
      return
17872 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17873 
    if self.success is not None:
17874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17876 
      for iter364 in self.success:
17877 
        iter364.write(oprot)
7291 vikram.rag 17878 
      oprot.writeListEnd()
17879 
      oprot.writeFieldEnd()
17880 
    oprot.writeFieldStop()
17881 
    oprot.writeStructEnd()
17882 
 
17883 
  def validate(self):
17884 
    return
17885 
 
17886 
 
17887 
  def __repr__(self):
17888 
    L = ['%s=%r' % (key, value)
17889 
      for key, value in self.__dict__.iteritems()]
17890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17891 
 
17892 
  def __eq__(self, other):
17893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17894 
 
17895 
  def __ne__(self, other):
17896 
    return not (self == other)
7460 kshitij.so 17897 
 
17898 
class updateItemInventory_args:
17899 
  """
17900 
  Attributes:
17901 
   - itemId
17902 
   - holdInventory
17903 
   - defaultInventory
17904 
  """
17905 
 
17906 
  thrift_spec = (
17907 
    None, # 0
17908 
    (1, TType.I64, 'itemId', None, None, ), # 1
17909 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
17910 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
17911 
  )
17912 
 
17913 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
17914 
    self.itemId = itemId
17915 
    self.holdInventory = holdInventory
17916 
    self.defaultInventory = defaultInventory
17917 
 
17918 
  def read(self, iprot):
17919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17921 
      return
17922 
    iprot.readStructBegin()
17923 
    while True:
17924 
      (fname, ftype, fid) = iprot.readFieldBegin()
17925 
      if ftype == TType.STOP:
17926 
        break
17927 
      if fid == 1:
17928 
        if ftype == TType.I64:
17929 
          self.itemId = iprot.readI64();
17930 
        else:
17931 
          iprot.skip(ftype)
17932 
      elif fid == 2:
17933 
        if ftype == TType.I64:
17934 
          self.holdInventory = iprot.readI64();
17935 
        else:
17936 
          iprot.skip(ftype)
17937 
      elif fid == 3:
17938 
        if ftype == TType.I64:
17939 
          self.defaultInventory = iprot.readI64();
17940 
        else:
17941 
          iprot.skip(ftype)
17942 
      else:
17943 
        iprot.skip(ftype)
17944 
      iprot.readFieldEnd()
17945 
    iprot.readStructEnd()
17946 
 
17947 
  def write(self, oprot):
17948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17950 
      return
17951 
    oprot.writeStructBegin('updateItemInventory_args')
17952 
    if self.itemId is not None:
17953 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17954 
      oprot.writeI64(self.itemId)
17955 
      oprot.writeFieldEnd()
17956 
    if self.holdInventory is not None:
17957 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
17958 
      oprot.writeI64(self.holdInventory)
17959 
      oprot.writeFieldEnd()
17960 
    if self.defaultInventory is not None:
17961 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
17962 
      oprot.writeI64(self.defaultInventory)
17963 
      oprot.writeFieldEnd()
17964 
    oprot.writeFieldStop()
17965 
    oprot.writeStructEnd()
17966 
 
17967 
  def validate(self):
17968 
    return
17969 
 
17970 
 
17971 
  def __repr__(self):
17972 
    L = ['%s=%r' % (key, value)
17973 
      for key, value in self.__dict__.iteritems()]
17974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17975 
 
17976 
  def __eq__(self, other):
17977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17978 
 
17979 
  def __ne__(self, other):
17980 
    return not (self == other)
17981 
 
17982 
class updateItemInventory_result:
17983 
  """
17984 
  Attributes:
17985 
   - success
17986 
  """
17987 
 
17988 
  thrift_spec = (
17989 
    (0, TType.BOOL, 'success', None, None, ), # 0
17990 
  )
17991 
 
17992 
  def __init__(self, success=None,):
17993 
    self.success = success
17994 
 
17995 
  def read(self, iprot):
17996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17998 
      return
17999 
    iprot.readStructBegin()
18000 
    while True:
18001 
      (fname, ftype, fid) = iprot.readFieldBegin()
18002 
      if ftype == TType.STOP:
18003 
        break
18004 
      if fid == 0:
18005 
        if ftype == TType.BOOL:
18006 
          self.success = iprot.readBool();
18007 
        else:
18008 
          iprot.skip(ftype)
18009 
      else:
18010 
        iprot.skip(ftype)
18011 
      iprot.readFieldEnd()
18012 
    iprot.readStructEnd()
18013 
 
18014 
  def write(self, oprot):
18015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18017 
      return
18018 
    oprot.writeStructBegin('updateItemInventory_result')
18019 
    if self.success is not None:
18020 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18021 
      oprot.writeBool(self.success)
18022 
      oprot.writeFieldEnd()
18023 
    oprot.writeFieldStop()
18024 
    oprot.writeStructEnd()
18025 
 
18026 
  def validate(self):
18027 
    return
18028 
 
18029 
 
18030 
  def __repr__(self):
18031 
    L = ['%s=%r' % (key, value)
18032 
      for key, value in self.__dict__.iteritems()]
18033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18034 
 
18035 
  def __eq__(self, other):
18036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18037 
 
18038 
  def __ne__(self, other):
18039 
    return not (self == other)
7770 kshitij.so 18040 
 
18041 
class updateTimestampForAmazonFeeds_args:
18042 
  """
18043 
  Attributes:
18044 
   - type
18045 
   - sku
18046 
   - timestamp
18047 
  """
18048 
 
18049 
  thrift_spec = (
18050 
    None, # 0
18051 
    (1, TType.STRING, 'type', None, None, ), # 1
18052 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18053 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18054 
  )
18055 
 
18056 
  def __init__(self, type=None, sku=None, timestamp=None,):
18057 
    self.type = type
18058 
    self.sku = sku
18059 
    self.timestamp = timestamp
18060 
 
18061 
  def read(self, iprot):
18062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18064 
      return
18065 
    iprot.readStructBegin()
18066 
    while True:
18067 
      (fname, ftype, fid) = iprot.readFieldBegin()
18068 
      if ftype == TType.STOP:
18069 
        break
18070 
      if fid == 1:
18071 
        if ftype == TType.STRING:
18072 
          self.type = iprot.readString();
18073 
        else:
18074 
          iprot.skip(ftype)
18075 
      elif fid == 2:
18076 
        if ftype == TType.LIST:
18077 
          self.sku = []
18078 
          (_etype368, _size365) = iprot.readListBegin()
18079 
          for _i369 in xrange(_size365):
18080 
            _elem370 = iprot.readI64();
18081 
            self.sku.append(_elem370)
18082 
          iprot.readListEnd()
18083 
        else:
18084 
          iprot.skip(ftype)
18085 
      elif fid == 3:
18086 
        if ftype == TType.I64:
18087 
          self.timestamp = iprot.readI64();
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      else:
18091 
        iprot.skip(ftype)
18092 
      iprot.readFieldEnd()
18093 
    iprot.readStructEnd()
18094 
 
18095 
  def write(self, oprot):
18096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18098 
      return
18099 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18100 
    if self.type is not None:
18101 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18102 
      oprot.writeString(self.type)
18103 
      oprot.writeFieldEnd()
18104 
    if self.sku is not None:
18105 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18106 
      oprot.writeListBegin(TType.I64, len(self.sku))
18107 
      for iter371 in self.sku:
18108 
        oprot.writeI64(iter371)
18109 
      oprot.writeListEnd()
18110 
      oprot.writeFieldEnd()
18111 
    if self.timestamp is not None:
18112 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18113 
      oprot.writeI64(self.timestamp)
18114 
      oprot.writeFieldEnd()
18115 
    oprot.writeFieldStop()
18116 
    oprot.writeStructEnd()
18117 
 
18118 
  def validate(self):
18119 
    return
18120 
 
18121 
 
18122 
  def __repr__(self):
18123 
    L = ['%s=%r' % (key, value)
18124 
      for key, value in self.__dict__.iteritems()]
18125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18126 
 
18127 
  def __eq__(self, other):
18128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18129 
 
18130 
  def __ne__(self, other):
18131 
    return not (self == other)
18132 
 
18133 
class updateTimestampForAmazonFeeds_result:
18134 
  """
18135 
  Attributes:
18136 
   - success
18137 
  """
18138 
 
18139 
  thrift_spec = (
18140 
    (0, TType.BOOL, 'success', None, None, ), # 0
18141 
  )
18142 
 
18143 
  def __init__(self, success=None,):
18144 
    self.success = success
18145 
 
18146 
  def read(self, iprot):
18147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18149 
      return
18150 
    iprot.readStructBegin()
18151 
    while True:
18152 
      (fname, ftype, fid) = iprot.readFieldBegin()
18153 
      if ftype == TType.STOP:
18154 
        break
18155 
      if fid == 0:
18156 
        if ftype == TType.BOOL:
18157 
          self.success = iprot.readBool();
18158 
        else:
18159 
          iprot.skip(ftype)
18160 
      else:
18161 
        iprot.skip(ftype)
18162 
      iprot.readFieldEnd()
18163 
    iprot.readStructEnd()
18164 
 
18165 
  def write(self, oprot):
18166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18168 
      return
18169 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18170 
    if self.success is not None:
18171 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18172 
      oprot.writeBool(self.success)
18173 
      oprot.writeFieldEnd()
18174 
    oprot.writeFieldStop()
18175 
    oprot.writeStructEnd()
18176 
 
18177 
  def validate(self):
18178 
    return
18179 
 
18180 
 
18181 
  def __repr__(self):
18182 
    L = ['%s=%r' % (key, value)
18183 
      for key, value in self.__dict__.iteritems()]
18184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18185 
 
18186 
  def __eq__(self, other):
18187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18188 
 
18189 
  def __ne__(self, other):
18190 
    return not (self == other)